Update vk.xml and code generator
This commit updates vk.xml and code generator to make them backward
compatible. The updates in code generator includes:
1. Parse "protect" properly.
2. Ignore "optional" if the "optional" was added in newer vk.xml.
- This is done by having an extra table for related fields.
3. Parse latexmath properly.
4. Parse "supported" properly.
5. Skip parameters and members if they are not for Vulkan API.
6. VkNativeBufferANDROID diverged from upstream, keep the old one.
Bug: 293346694
Test: rebuild and run aemu with older system images
Change-Id: I72dad62bcbeb041bb49f1a6467ec5af2a1ef7960
diff --git a/host/vulkan/VkSubDecoder.cpp b/host/vulkan/VkSubDecoder.cpp
index 3f4660f..6f5f700 100644
--- a/host/vulkan/VkSubDecoder.cpp
+++ b/host/vulkan/VkSubDecoder.cpp
@@ -1534,6 +1534,506 @@
break;
}
#endif
+#ifdef VK_VERSION_1_3
+ case OP_vkCmdSetEvent2: {
+ android::base::beginTrace("vkCmdSetEvent2 subdecode");
+ VkEvent event;
+ const VkDependencyInfo* pDependencyInfo;
+ VkDependencyInfo stack_pDependencyInfo[1];
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
+ pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
+ reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDependencyInfo*)(pDependencyInfo),
+ readStreamPtrPtr);
+ if (pDependencyInfo) {
+ transform_tohost_VkDependencyInfo(globalstate,
+ (VkDependencyInfo*)(pDependencyInfo));
+ }
+ vk->vkCmdSetEvent2((VkCommandBuffer)dispatchHandle, event, pDependencyInfo);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdResetEvent2: {
+ android::base::beginTrace("vkCmdResetEvent2 subdecode");
+ VkEvent event;
+ VkPipelineStageFlags2 stageMask;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
+ memcpy((VkPipelineStageFlags2*)&stageMask, *readStreamPtrPtr,
+ sizeof(VkPipelineStageFlags2));
+ *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
+ vk->vkCmdResetEvent2((VkCommandBuffer)dispatchHandle, event, stageMask);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdWaitEvents2: {
+ android::base::beginTrace("vkCmdWaitEvents2 subdecode");
+ uint32_t eventCount;
+ const VkEvent* pEvents;
+ VkEvent stack_pEvents[MAX_STACK_ITEMS];
+ const VkDependencyInfo* pDependencyInfos;
+ VkDependencyInfo stack_pDependencyInfos[MAX_STACK_ITEMS];
+ memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (((eventCount)) <= MAX_STACK_ITEMS) {
+ pEvents = (VkEvent*)stack_pEvents;
+ } else {
+ readStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
+ }
+ if (((eventCount))) {
+ uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
+ *readStreamPtrPtr += 8 * ((eventCount));
+ for (uint32_t k = 0; k < ((eventCount)); ++k) {
+ uint64_t tmpval;
+ memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
+ *(((VkEvent*)pEvents) + k) = (VkEvent)unbox_VkEvent((VkEvent)tmpval);
+ }
+ }
+ if (((eventCount)) <= MAX_STACK_ITEMS) {
+ pDependencyInfos = (VkDependencyInfo*)stack_pDependencyInfos;
+ } else {
+ readStream->alloc((void**)&pDependencyInfos,
+ ((eventCount)) * sizeof(const VkDependencyInfo));
+ }
+ for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
+ reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDependencyInfo*)(pDependencyInfos + i),
+ readStreamPtrPtr);
+ }
+ if (pDependencyInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
+ transform_tohost_VkDependencyInfo(
+ globalstate, (VkDependencyInfo*)(pDependencyInfos + i));
+ }
+ }
+ vk->vkCmdWaitEvents2((VkCommandBuffer)dispatchHandle, eventCount, pEvents,
+ pDependencyInfos);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdPipelineBarrier2: {
+ android::base::beginTrace("vkCmdPipelineBarrier2 subdecode");
+ const VkDependencyInfo* pDependencyInfo;
+ VkDependencyInfo stack_pDependencyInfo[1];
+ pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
+ reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDependencyInfo*)(pDependencyInfo),
+ readStreamPtrPtr);
+ if (pDependencyInfo) {
+ transform_tohost_VkDependencyInfo(globalstate,
+ (VkDependencyInfo*)(pDependencyInfo));
+ }
+ vk->vkCmdPipelineBarrier2((VkCommandBuffer)dispatchHandle, pDependencyInfo);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdWriteTimestamp2: {
+ android::base::beginTrace("vkCmdWriteTimestamp2 subdecode");
+ VkPipelineStageFlags2 stage;
+ VkQueryPool queryPool;
+ uint32_t query;
+ memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
+ sizeof(VkPipelineStageFlags2));
+ *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkQueryPool*)&queryPool =
+ (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
+ memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ vk->vkCmdWriteTimestamp2((VkCommandBuffer)dispatchHandle, stage, queryPool, query);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdCopyBuffer2: {
+ android::base::beginTrace("vkCmdCopyBuffer2 subdecode");
+ const VkCopyBufferInfo2* pCopyBufferInfo;
+ VkCopyBufferInfo2 stack_pCopyBufferInfo[1];
+ pCopyBufferInfo = (VkCopyBufferInfo2*)stack_pCopyBufferInfo;
+ reservedunmarshal_VkCopyBufferInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyBufferInfo2*)(pCopyBufferInfo),
+ readStreamPtrPtr);
+ if (pCopyBufferInfo) {
+ transform_tohost_VkCopyBufferInfo2(globalstate,
+ (VkCopyBufferInfo2*)(pCopyBufferInfo));
+ }
+ vk->vkCmdCopyBuffer2((VkCommandBuffer)dispatchHandle, pCopyBufferInfo);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdCopyImage2: {
+ android::base::beginTrace("vkCmdCopyImage2 subdecode");
+ const VkCopyImageInfo2* pCopyImageInfo;
+ VkCopyImageInfo2 stack_pCopyImageInfo[1];
+ pCopyImageInfo = (VkCopyImageInfo2*)stack_pCopyImageInfo;
+ reservedunmarshal_VkCopyImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyImageInfo2*)(pCopyImageInfo),
+ readStreamPtrPtr);
+ if (pCopyImageInfo) {
+ transform_tohost_VkCopyImageInfo2(globalstate,
+ (VkCopyImageInfo2*)(pCopyImageInfo));
+ }
+ vk->vkCmdCopyImage2((VkCommandBuffer)dispatchHandle, pCopyImageInfo);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdCopyBufferToImage2: {
+ android::base::beginTrace("vkCmdCopyBufferToImage2 subdecode");
+ const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo;
+ VkCopyBufferToImageInfo2 stack_pCopyBufferToImageInfo[1];
+ pCopyBufferToImageInfo = (VkCopyBufferToImageInfo2*)stack_pCopyBufferToImageInfo;
+ reservedunmarshal_VkCopyBufferToImageInfo2(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo), readStreamPtrPtr);
+ if (pCopyBufferToImageInfo) {
+ transform_tohost_VkCopyBufferToImageInfo2(
+ globalstate, (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo));
+ }
+ vk->vkCmdCopyBufferToImage2((VkCommandBuffer)dispatchHandle,
+ pCopyBufferToImageInfo);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdCopyImageToBuffer2: {
+ android::base::beginTrace("vkCmdCopyImageToBuffer2 subdecode");
+ const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo;
+ VkCopyImageToBufferInfo2 stack_pCopyImageToBufferInfo[1];
+ pCopyImageToBufferInfo = (VkCopyImageToBufferInfo2*)stack_pCopyImageToBufferInfo;
+ reservedunmarshal_VkCopyImageToBufferInfo2(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo), readStreamPtrPtr);
+ if (pCopyImageToBufferInfo) {
+ transform_tohost_VkCopyImageToBufferInfo2(
+ globalstate, (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo));
+ }
+ vk->vkCmdCopyImageToBuffer2((VkCommandBuffer)dispatchHandle,
+ pCopyImageToBufferInfo);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdBlitImage2: {
+ android::base::beginTrace("vkCmdBlitImage2 subdecode");
+ const VkBlitImageInfo2* pBlitImageInfo;
+ VkBlitImageInfo2 stack_pBlitImageInfo[1];
+ pBlitImageInfo = (VkBlitImageInfo2*)stack_pBlitImageInfo;
+ reservedunmarshal_VkBlitImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBlitImageInfo2*)(pBlitImageInfo),
+ readStreamPtrPtr);
+ if (pBlitImageInfo) {
+ transform_tohost_VkBlitImageInfo2(globalstate,
+ (VkBlitImageInfo2*)(pBlitImageInfo));
+ }
+ vk->vkCmdBlitImage2((VkCommandBuffer)dispatchHandle, pBlitImageInfo);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdResolveImage2: {
+ android::base::beginTrace("vkCmdResolveImage2 subdecode");
+ const VkResolveImageInfo2* pResolveImageInfo;
+ VkResolveImageInfo2 stack_pResolveImageInfo[1];
+ pResolveImageInfo = (VkResolveImageInfo2*)stack_pResolveImageInfo;
+ reservedunmarshal_VkResolveImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkResolveImageInfo2*)(pResolveImageInfo),
+ readStreamPtrPtr);
+ if (pResolveImageInfo) {
+ transform_tohost_VkResolveImageInfo2(globalstate,
+ (VkResolveImageInfo2*)(pResolveImageInfo));
+ }
+ vk->vkCmdResolveImage2((VkCommandBuffer)dispatchHandle, pResolveImageInfo);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdBeginRendering: {
+ android::base::beginTrace("vkCmdBeginRendering subdecode");
+ const VkRenderingInfo* pRenderingInfo;
+ VkRenderingInfo stack_pRenderingInfo[1];
+ pRenderingInfo = (VkRenderingInfo*)stack_pRenderingInfo;
+ reservedunmarshal_VkRenderingInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderingInfo*)(pRenderingInfo),
+ readStreamPtrPtr);
+ if (pRenderingInfo) {
+ transform_tohost_VkRenderingInfo(globalstate,
+ (VkRenderingInfo*)(pRenderingInfo));
+ }
+ vk->vkCmdBeginRendering((VkCommandBuffer)dispatchHandle, pRenderingInfo);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdEndRendering: {
+ android::base::beginTrace("vkCmdEndRendering subdecode");
+ vk->vkCmdEndRendering((VkCommandBuffer)dispatchHandle);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetCullMode: {
+ android::base::beginTrace("vkCmdSetCullMode subdecode");
+ VkCullModeFlags cullMode;
+ memcpy((VkCullModeFlags*)&cullMode, *readStreamPtrPtr, sizeof(VkCullModeFlags));
+ *readStreamPtrPtr += sizeof(VkCullModeFlags);
+ vk->vkCmdSetCullMode((VkCommandBuffer)dispatchHandle, cullMode);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetFrontFace: {
+ android::base::beginTrace("vkCmdSetFrontFace subdecode");
+ VkFrontFace frontFace;
+ memcpy((VkFrontFace*)&frontFace, *readStreamPtrPtr, sizeof(VkFrontFace));
+ *readStreamPtrPtr += sizeof(VkFrontFace);
+ vk->vkCmdSetFrontFace((VkCommandBuffer)dispatchHandle, frontFace);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetPrimitiveTopology: {
+ android::base::beginTrace("vkCmdSetPrimitiveTopology subdecode");
+ VkPrimitiveTopology primitiveTopology;
+ memcpy((VkPrimitiveTopology*)&primitiveTopology, *readStreamPtrPtr,
+ sizeof(VkPrimitiveTopology));
+ *readStreamPtrPtr += sizeof(VkPrimitiveTopology);
+ vk->vkCmdSetPrimitiveTopology((VkCommandBuffer)dispatchHandle, primitiveTopology);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetViewportWithCount: {
+ android::base::beginTrace("vkCmdSetViewportWithCount subdecode");
+ uint32_t viewportCount;
+ const VkViewport* pViewports;
+ VkViewport stack_pViewports[MAX_STACK_ITEMS];
+ memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (((viewportCount)) <= MAX_STACK_ITEMS) {
+ pViewports = (VkViewport*)stack_pViewports;
+ } else {
+ readStream->alloc((void**)&pViewports,
+ ((viewportCount)) * sizeof(const VkViewport));
+ }
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ reservedunmarshal_VkViewport(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkViewport*)(pViewports + i), readStreamPtrPtr);
+ }
+ if (pViewports) {
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ transform_tohost_VkViewport(globalstate, (VkViewport*)(pViewports + i));
+ }
+ }
+ vk->vkCmdSetViewportWithCount((VkCommandBuffer)dispatchHandle, viewportCount,
+ pViewports);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetScissorWithCount: {
+ android::base::beginTrace("vkCmdSetScissorWithCount subdecode");
+ uint32_t scissorCount;
+ const VkRect2D* pScissors;
+ VkRect2D stack_pScissors[MAX_STACK_ITEMS];
+ memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (((scissorCount)) <= MAX_STACK_ITEMS) {
+ pScissors = (VkRect2D*)stack_pScissors;
+ } else {
+ readStream->alloc((void**)&pScissors,
+ ((scissorCount)) * sizeof(const VkRect2D));
+ }
+ for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
+ reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRect2D*)(pScissors + i), readStreamPtrPtr);
+ }
+ if (pScissors) {
+ for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
+ transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pScissors + i));
+ }
+ }
+ vk->vkCmdSetScissorWithCount((VkCommandBuffer)dispatchHandle, scissorCount,
+ pScissors);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdBindVertexBuffers2: {
+ android::base::beginTrace("vkCmdBindVertexBuffers2 subdecode");
+ uint32_t firstBinding;
+ uint32_t bindingCount;
+ const VkBuffer* pBuffers;
+ VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
+ const VkDeviceSize* pOffsets;
+ VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
+ const VkDeviceSize* pSizes;
+ VkDeviceSize stack_pSizes[MAX_STACK_ITEMS];
+ const VkDeviceSize* pStrides;
+ VkDeviceSize stack_pStrides[MAX_STACK_ITEMS];
+ memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ memcpy((VkBuffer**)&pBuffers, (*readStreamPtrPtr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&pBuffers);
+ *readStreamPtrPtr += 8;
+ if (pBuffers) {
+ if (((bindingCount)) <= MAX_STACK_ITEMS) {
+ pBuffers = (VkBuffer*)stack_pBuffers;
+ } else {
+ readStream->alloc((void**)&pBuffers,
+ ((bindingCount)) * sizeof(const VkBuffer));
+ }
+ if (((bindingCount))) {
+ uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
+ *readStreamPtrPtr += 8 * ((bindingCount));
+ for (uint32_t k = 0; k < ((bindingCount)); ++k) {
+ uint64_t tmpval;
+ memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
+ *(((VkBuffer*)pBuffers) + k) =
+ (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval);
+ }
+ }
+ }
+ if (((bindingCount)) <= MAX_STACK_ITEMS) {
+ pOffsets = (VkDeviceSize*)stack_pOffsets;
+ } else {
+ readStream->alloc((void**)&pOffsets,
+ ((bindingCount)) * sizeof(const VkDeviceSize));
+ }
+ memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
+ ((bindingCount)) * sizeof(const VkDeviceSize));
+ *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
+ // WARNING PTR CHECK
+ memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&pSizes);
+ *readStreamPtrPtr += 8;
+ if (pSizes) {
+ if (((bindingCount)) <= MAX_STACK_ITEMS) {
+ pSizes = (VkDeviceSize*)stack_pSizes;
+ } else {
+ readStream->alloc((void**)&pSizes,
+ ((bindingCount)) * sizeof(const VkDeviceSize));
+ }
+ memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr,
+ ((bindingCount)) * sizeof(const VkDeviceSize));
+ *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
+ }
+ // WARNING PTR CHECK
+ memcpy((VkDeviceSize**)&pStrides, (*readStreamPtrPtr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&pStrides);
+ *readStreamPtrPtr += 8;
+ if (pStrides) {
+ if (((bindingCount)) <= MAX_STACK_ITEMS) {
+ pStrides = (VkDeviceSize*)stack_pStrides;
+ } else {
+ readStream->alloc((void**)&pStrides,
+ ((bindingCount)) * sizeof(const VkDeviceSize));
+ }
+ memcpy((VkDeviceSize*)pStrides, *readStreamPtrPtr,
+ ((bindingCount)) * sizeof(const VkDeviceSize));
+ *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
+ }
+ vk->vkCmdBindVertexBuffers2((VkCommandBuffer)dispatchHandle, firstBinding,
+ bindingCount, pBuffers, pOffsets, pSizes, pStrides);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetDepthTestEnable: {
+ android::base::beginTrace("vkCmdSetDepthTestEnable subdecode");
+ VkBool32 depthTestEnable;
+ memcpy((VkBool32*)&depthTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetDepthTestEnable((VkCommandBuffer)dispatchHandle, depthTestEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetDepthWriteEnable: {
+ android::base::beginTrace("vkCmdSetDepthWriteEnable subdecode");
+ VkBool32 depthWriteEnable;
+ memcpy((VkBool32*)&depthWriteEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetDepthWriteEnable((VkCommandBuffer)dispatchHandle, depthWriteEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetDepthCompareOp: {
+ android::base::beginTrace("vkCmdSetDepthCompareOp subdecode");
+ VkCompareOp depthCompareOp;
+ memcpy((VkCompareOp*)&depthCompareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
+ *readStreamPtrPtr += sizeof(VkCompareOp);
+ vk->vkCmdSetDepthCompareOp((VkCommandBuffer)dispatchHandle, depthCompareOp);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetDepthBoundsTestEnable: {
+ android::base::beginTrace("vkCmdSetDepthBoundsTestEnable subdecode");
+ VkBool32 depthBoundsTestEnable;
+ memcpy((VkBool32*)&depthBoundsTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetDepthBoundsTestEnable((VkCommandBuffer)dispatchHandle,
+ depthBoundsTestEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetStencilTestEnable: {
+ android::base::beginTrace("vkCmdSetStencilTestEnable subdecode");
+ VkBool32 stencilTestEnable;
+ memcpy((VkBool32*)&stencilTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetStencilTestEnable((VkCommandBuffer)dispatchHandle, stencilTestEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetStencilOp: {
+ android::base::beginTrace("vkCmdSetStencilOp subdecode");
+ VkStencilFaceFlags faceMask;
+ VkStencilOp failOp;
+ VkStencilOp passOp;
+ VkStencilOp depthFailOp;
+ VkCompareOp compareOp;
+ memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
+ sizeof(VkStencilFaceFlags));
+ *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
+ memcpy((VkStencilOp*)&failOp, *readStreamPtrPtr, sizeof(VkStencilOp));
+ *readStreamPtrPtr += sizeof(VkStencilOp);
+ memcpy((VkStencilOp*)&passOp, *readStreamPtrPtr, sizeof(VkStencilOp));
+ *readStreamPtrPtr += sizeof(VkStencilOp);
+ memcpy((VkStencilOp*)&depthFailOp, *readStreamPtrPtr, sizeof(VkStencilOp));
+ *readStreamPtrPtr += sizeof(VkStencilOp);
+ memcpy((VkCompareOp*)&compareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
+ *readStreamPtrPtr += sizeof(VkCompareOp);
+ vk->vkCmdSetStencilOp((VkCommandBuffer)dispatchHandle, faceMask, failOp, passOp,
+ depthFailOp, compareOp);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetRasterizerDiscardEnable: {
+ android::base::beginTrace("vkCmdSetRasterizerDiscardEnable subdecode");
+ VkBool32 rasterizerDiscardEnable;
+ memcpy((VkBool32*)&rasterizerDiscardEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetRasterizerDiscardEnable((VkCommandBuffer)dispatchHandle,
+ rasterizerDiscardEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetDepthBiasEnable: {
+ android::base::beginTrace("vkCmdSetDepthBiasEnable subdecode");
+ VkBool32 depthBiasEnable;
+ memcpy((VkBool32*)&depthBiasEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetDepthBiasEnable((VkCommandBuffer)dispatchHandle, depthBiasEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetPrimitiveRestartEnable: {
+ android::base::beginTrace("vkCmdSetPrimitiveRestartEnable subdecode");
+ VkBool32 primitiveRestartEnable;
+ memcpy((VkBool32*)&primitiveRestartEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetPrimitiveRestartEnable((VkCommandBuffer)dispatchHandle,
+ primitiveRestartEnable);
+ android::base::endTrace();
+ break;
+ }
+#endif
#ifdef VK_KHR_surface
#endif
#ifdef VK_KHR_swapchain
@@ -1607,33 +2107,35 @@
#ifdef VK_KHR_video_decode_queue
case OP_vkCmdDecodeVideoKHR: {
android::base::beginTrace("vkCmdDecodeVideoKHR subdecode");
- const VkVideoDecodeInfoKHR* pFrameInfo;
- VkVideoDecodeInfoKHR stack_pFrameInfo[1];
- pFrameInfo = (VkVideoDecodeInfoKHR*)stack_pFrameInfo;
+ const VkVideoDecodeInfoKHR* pDecodeInfo;
+ VkVideoDecodeInfoKHR stack_pDecodeInfo[1];
+ pDecodeInfo = (VkVideoDecodeInfoKHR*)stack_pDecodeInfo;
reservedunmarshal_VkVideoDecodeInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkVideoDecodeInfoKHR*)(pFrameInfo),
+ (VkVideoDecodeInfoKHR*)(pDecodeInfo),
readStreamPtrPtr);
- if (pFrameInfo) {
+ if (pDecodeInfo) {
transform_tohost_VkVideoDecodeInfoKHR(globalstate,
- (VkVideoDecodeInfoKHR*)(pFrameInfo));
+ (VkVideoDecodeInfoKHR*)(pDecodeInfo));
}
- vk->vkCmdDecodeVideoKHR((VkCommandBuffer)dispatchHandle, pFrameInfo);
+ vk->vkCmdDecodeVideoKHR((VkCommandBuffer)dispatchHandle, pDecodeInfo);
android::base::endTrace();
break;
}
#endif
+#ifdef VK_KHR_video_decode_h264
+#endif
#ifdef VK_KHR_dynamic_rendering
case OP_vkCmdBeginRenderingKHR: {
android::base::beginTrace("vkCmdBeginRenderingKHR subdecode");
- const VkRenderingInfoKHR* pRenderingInfo;
- VkRenderingInfoKHR stack_pRenderingInfo[1];
- pRenderingInfo = (VkRenderingInfoKHR*)stack_pRenderingInfo;
- reservedunmarshal_VkRenderingInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkRenderingInfoKHR*)(pRenderingInfo),
- readStreamPtrPtr);
+ const VkRenderingInfo* pRenderingInfo;
+ VkRenderingInfo stack_pRenderingInfo[1];
+ pRenderingInfo = (VkRenderingInfo*)stack_pRenderingInfo;
+ reservedunmarshal_VkRenderingInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderingInfo*)(pRenderingInfo),
+ readStreamPtrPtr);
if (pRenderingInfo) {
- transform_tohost_VkRenderingInfoKHR(globalstate,
- (VkRenderingInfoKHR*)(pRenderingInfo));
+ transform_tohost_VkRenderingInfo(globalstate,
+ (VkRenderingInfo*)(pRenderingInfo));
}
vk->vkCmdBeginRenderingKHR((VkCommandBuffer)dispatchHandle, pRenderingInfo);
android::base::endTrace();
@@ -1978,6 +2480,10 @@
#endif
#ifdef VK_KHR_shader_clock
#endif
+#ifdef VK_KHR_video_decode_h265
+#endif
+#ifdef VK_KHR_global_priority
+#endif
#ifdef VK_KHR_driver_properties
#endif
#ifdef VK_KHR_shader_float_controls
@@ -2029,6 +2535,8 @@
#endif
#ifdef VK_KHR_pipeline_executable_properties
#endif
+#ifdef VK_KHR_map_memory2
+#endif
#ifdef VK_KHR_shader_integer_dot_product
#endif
#ifdef VK_KHR_pipeline_library
@@ -2059,19 +2567,19 @@
case OP_vkCmdSetEvent2KHR: {
android::base::beginTrace("vkCmdSetEvent2KHR subdecode");
VkEvent event;
- const VkDependencyInfoKHR* pDependencyInfo;
- VkDependencyInfoKHR stack_pDependencyInfo[1];
+ const VkDependencyInfo* pDependencyInfo;
+ VkDependencyInfo stack_pDependencyInfo[1];
uint64_t cgen_var_0;
memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
*readStreamPtrPtr += 1 * 8;
*(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
- pDependencyInfo = (VkDependencyInfoKHR*)stack_pDependencyInfo;
- reservedunmarshal_VkDependencyInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkDependencyInfoKHR*)(pDependencyInfo),
- readStreamPtrPtr);
+ pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
+ reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDependencyInfo*)(pDependencyInfo),
+ readStreamPtrPtr);
if (pDependencyInfo) {
- transform_tohost_VkDependencyInfoKHR(globalstate,
- (VkDependencyInfoKHR*)(pDependencyInfo));
+ transform_tohost_VkDependencyInfo(globalstate,
+ (VkDependencyInfo*)(pDependencyInfo));
}
vk->vkCmdSetEvent2KHR((VkCommandBuffer)dispatchHandle, event, pDependencyInfo);
android::base::endTrace();
@@ -2080,14 +2588,14 @@
case OP_vkCmdResetEvent2KHR: {
android::base::beginTrace("vkCmdResetEvent2KHR subdecode");
VkEvent event;
- VkPipelineStageFlags2KHR stageMask;
+ VkPipelineStageFlags2 stageMask;
uint64_t cgen_var_0;
memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
*readStreamPtrPtr += 1 * 8;
*(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
- memcpy((VkPipelineStageFlags2KHR*)&stageMask, *readStreamPtrPtr,
- sizeof(VkPipelineStageFlags2KHR));
- *readStreamPtrPtr += sizeof(VkPipelineStageFlags2KHR);
+ memcpy((VkPipelineStageFlags2*)&stageMask, *readStreamPtrPtr,
+ sizeof(VkPipelineStageFlags2));
+ *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
vk->vkCmdResetEvent2KHR((VkCommandBuffer)dispatchHandle, event, stageMask);
android::base::endTrace();
break;
@@ -2097,8 +2605,8 @@
uint32_t eventCount;
const VkEvent* pEvents;
VkEvent stack_pEvents[MAX_STACK_ITEMS];
- const VkDependencyInfoKHR* pDependencyInfos;
- VkDependencyInfoKHR stack_pDependencyInfos[MAX_STACK_ITEMS];
+ const VkDependencyInfo* pDependencyInfos;
+ VkDependencyInfo stack_pDependencyInfos[MAX_STACK_ITEMS];
memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
*readStreamPtrPtr += sizeof(uint32_t);
if (((eventCount)) <= MAX_STACK_ITEMS) {
@@ -2116,20 +2624,20 @@
}
}
if (((eventCount)) <= MAX_STACK_ITEMS) {
- pDependencyInfos = (VkDependencyInfoKHR*)stack_pDependencyInfos;
+ pDependencyInfos = (VkDependencyInfo*)stack_pDependencyInfos;
} else {
readStream->alloc((void**)&pDependencyInfos,
- ((eventCount)) * sizeof(const VkDependencyInfoKHR));
+ ((eventCount)) * sizeof(const VkDependencyInfo));
}
for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
- reservedunmarshal_VkDependencyInfoKHR(
- readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkDependencyInfoKHR*)(pDependencyInfos + i), readStreamPtrPtr);
+ reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDependencyInfo*)(pDependencyInfos + i),
+ readStreamPtrPtr);
}
if (pDependencyInfos) {
for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
- transform_tohost_VkDependencyInfoKHR(
- globalstate, (VkDependencyInfoKHR*)(pDependencyInfos + i));
+ transform_tohost_VkDependencyInfo(
+ globalstate, (VkDependencyInfo*)(pDependencyInfos + i));
}
}
vk->vkCmdWaitEvents2KHR((VkCommandBuffer)dispatchHandle, eventCount, pEvents,
@@ -2139,15 +2647,15 @@
}
case OP_vkCmdPipelineBarrier2KHR: {
android::base::beginTrace("vkCmdPipelineBarrier2KHR subdecode");
- const VkDependencyInfoKHR* pDependencyInfo;
- VkDependencyInfoKHR stack_pDependencyInfo[1];
- pDependencyInfo = (VkDependencyInfoKHR*)stack_pDependencyInfo;
- reservedunmarshal_VkDependencyInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkDependencyInfoKHR*)(pDependencyInfo),
- readStreamPtrPtr);
+ const VkDependencyInfo* pDependencyInfo;
+ VkDependencyInfo stack_pDependencyInfo[1];
+ pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
+ reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDependencyInfo*)(pDependencyInfo),
+ readStreamPtrPtr);
if (pDependencyInfo) {
- transform_tohost_VkDependencyInfoKHR(globalstate,
- (VkDependencyInfoKHR*)(pDependencyInfo));
+ transform_tohost_VkDependencyInfo(globalstate,
+ (VkDependencyInfo*)(pDependencyInfo));
}
vk->vkCmdPipelineBarrier2KHR((VkCommandBuffer)dispatchHandle, pDependencyInfo);
android::base::endTrace();
@@ -2155,12 +2663,12 @@
}
case OP_vkCmdWriteTimestamp2KHR: {
android::base::beginTrace("vkCmdWriteTimestamp2KHR subdecode");
- VkPipelineStageFlags2KHR stage;
+ VkPipelineStageFlags2 stage;
VkQueryPool queryPool;
uint32_t query;
- memcpy((VkPipelineStageFlags2KHR*)&stage, *readStreamPtrPtr,
- sizeof(VkPipelineStageFlags2KHR));
- *readStreamPtrPtr += sizeof(VkPipelineStageFlags2KHR);
+ memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
+ sizeof(VkPipelineStageFlags2));
+ *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
uint64_t cgen_var_0;
memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
*readStreamPtrPtr += 1 * 8;
@@ -2175,13 +2683,13 @@
}
case OP_vkCmdWriteBufferMarker2AMD: {
android::base::beginTrace("vkCmdWriteBufferMarker2AMD subdecode");
- VkPipelineStageFlags2KHR stage;
+ VkPipelineStageFlags2 stage;
VkBuffer dstBuffer;
VkDeviceSize dstOffset;
uint32_t marker;
- memcpy((VkPipelineStageFlags2KHR*)&stage, *readStreamPtrPtr,
- sizeof(VkPipelineStageFlags2KHR));
- *readStreamPtrPtr += sizeof(VkPipelineStageFlags2KHR);
+ memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
+ sizeof(VkPipelineStageFlags2));
+ *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
uint64_t cgen_var_0;
memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
*readStreamPtrPtr += 1 * 8;
@@ -2196,6 +2704,8 @@
break;
}
#endif
+#ifdef VK_KHR_fragment_shader_barycentric
+#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
@@ -2205,15 +2715,15 @@
#ifdef VK_KHR_copy_commands2
case OP_vkCmdCopyBuffer2KHR: {
android::base::beginTrace("vkCmdCopyBuffer2KHR subdecode");
- const VkCopyBufferInfo2KHR* pCopyBufferInfo;
- VkCopyBufferInfo2KHR stack_pCopyBufferInfo[1];
- pCopyBufferInfo = (VkCopyBufferInfo2KHR*)stack_pCopyBufferInfo;
- reservedunmarshal_VkCopyBufferInfo2KHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkCopyBufferInfo2KHR*)(pCopyBufferInfo),
- readStreamPtrPtr);
+ const VkCopyBufferInfo2* pCopyBufferInfo;
+ VkCopyBufferInfo2 stack_pCopyBufferInfo[1];
+ pCopyBufferInfo = (VkCopyBufferInfo2*)stack_pCopyBufferInfo;
+ reservedunmarshal_VkCopyBufferInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyBufferInfo2*)(pCopyBufferInfo),
+ readStreamPtrPtr);
if (pCopyBufferInfo) {
- transform_tohost_VkCopyBufferInfo2KHR(globalstate,
- (VkCopyBufferInfo2KHR*)(pCopyBufferInfo));
+ transform_tohost_VkCopyBufferInfo2(globalstate,
+ (VkCopyBufferInfo2*)(pCopyBufferInfo));
}
vk->vkCmdCopyBuffer2KHR((VkCommandBuffer)dispatchHandle, pCopyBufferInfo);
android::base::endTrace();
@@ -2221,15 +2731,15 @@
}
case OP_vkCmdCopyImage2KHR: {
android::base::beginTrace("vkCmdCopyImage2KHR subdecode");
- const VkCopyImageInfo2KHR* pCopyImageInfo;
- VkCopyImageInfo2KHR stack_pCopyImageInfo[1];
- pCopyImageInfo = (VkCopyImageInfo2KHR*)stack_pCopyImageInfo;
- reservedunmarshal_VkCopyImageInfo2KHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkCopyImageInfo2KHR*)(pCopyImageInfo),
- readStreamPtrPtr);
+ const VkCopyImageInfo2* pCopyImageInfo;
+ VkCopyImageInfo2 stack_pCopyImageInfo[1];
+ pCopyImageInfo = (VkCopyImageInfo2*)stack_pCopyImageInfo;
+ reservedunmarshal_VkCopyImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyImageInfo2*)(pCopyImageInfo),
+ readStreamPtrPtr);
if (pCopyImageInfo) {
- transform_tohost_VkCopyImageInfo2KHR(globalstate,
- (VkCopyImageInfo2KHR*)(pCopyImageInfo));
+ transform_tohost_VkCopyImageInfo2(globalstate,
+ (VkCopyImageInfo2*)(pCopyImageInfo));
}
vk->vkCmdCopyImage2KHR((VkCommandBuffer)dispatchHandle, pCopyImageInfo);
android::base::endTrace();
@@ -2237,15 +2747,15 @@
}
case OP_vkCmdCopyBufferToImage2KHR: {
android::base::beginTrace("vkCmdCopyBufferToImage2KHR subdecode");
- const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo;
- VkCopyBufferToImageInfo2KHR stack_pCopyBufferToImageInfo[1];
- pCopyBufferToImageInfo = (VkCopyBufferToImageInfo2KHR*)stack_pCopyBufferToImageInfo;
- reservedunmarshal_VkCopyBufferToImageInfo2KHR(
+ const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo;
+ VkCopyBufferToImageInfo2 stack_pCopyBufferToImageInfo[1];
+ pCopyBufferToImageInfo = (VkCopyBufferToImageInfo2*)stack_pCopyBufferToImageInfo;
+ reservedunmarshal_VkCopyBufferToImageInfo2(
readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkCopyBufferToImageInfo2KHR*)(pCopyBufferToImageInfo), readStreamPtrPtr);
+ (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo), readStreamPtrPtr);
if (pCopyBufferToImageInfo) {
- transform_tohost_VkCopyBufferToImageInfo2KHR(
- globalstate, (VkCopyBufferToImageInfo2KHR*)(pCopyBufferToImageInfo));
+ transform_tohost_VkCopyBufferToImageInfo2(
+ globalstate, (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo));
}
vk->vkCmdCopyBufferToImage2KHR((VkCommandBuffer)dispatchHandle,
pCopyBufferToImageInfo);
@@ -2254,15 +2764,15 @@
}
case OP_vkCmdCopyImageToBuffer2KHR: {
android::base::beginTrace("vkCmdCopyImageToBuffer2KHR subdecode");
- const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo;
- VkCopyImageToBufferInfo2KHR stack_pCopyImageToBufferInfo[1];
- pCopyImageToBufferInfo = (VkCopyImageToBufferInfo2KHR*)stack_pCopyImageToBufferInfo;
- reservedunmarshal_VkCopyImageToBufferInfo2KHR(
+ const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo;
+ VkCopyImageToBufferInfo2 stack_pCopyImageToBufferInfo[1];
+ pCopyImageToBufferInfo = (VkCopyImageToBufferInfo2*)stack_pCopyImageToBufferInfo;
+ reservedunmarshal_VkCopyImageToBufferInfo2(
readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkCopyImageToBufferInfo2KHR*)(pCopyImageToBufferInfo), readStreamPtrPtr);
+ (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo), readStreamPtrPtr);
if (pCopyImageToBufferInfo) {
- transform_tohost_VkCopyImageToBufferInfo2KHR(
- globalstate, (VkCopyImageToBufferInfo2KHR*)(pCopyImageToBufferInfo));
+ transform_tohost_VkCopyImageToBufferInfo2(
+ globalstate, (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo));
}
vk->vkCmdCopyImageToBuffer2KHR((VkCommandBuffer)dispatchHandle,
pCopyImageToBufferInfo);
@@ -2271,15 +2781,15 @@
}
case OP_vkCmdBlitImage2KHR: {
android::base::beginTrace("vkCmdBlitImage2KHR subdecode");
- const VkBlitImageInfo2KHR* pBlitImageInfo;
- VkBlitImageInfo2KHR stack_pBlitImageInfo[1];
- pBlitImageInfo = (VkBlitImageInfo2KHR*)stack_pBlitImageInfo;
- reservedunmarshal_VkBlitImageInfo2KHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkBlitImageInfo2KHR*)(pBlitImageInfo),
- readStreamPtrPtr);
+ const VkBlitImageInfo2* pBlitImageInfo;
+ VkBlitImageInfo2 stack_pBlitImageInfo[1];
+ pBlitImageInfo = (VkBlitImageInfo2*)stack_pBlitImageInfo;
+ reservedunmarshal_VkBlitImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBlitImageInfo2*)(pBlitImageInfo),
+ readStreamPtrPtr);
if (pBlitImageInfo) {
- transform_tohost_VkBlitImageInfo2KHR(globalstate,
- (VkBlitImageInfo2KHR*)(pBlitImageInfo));
+ transform_tohost_VkBlitImageInfo2(globalstate,
+ (VkBlitImageInfo2*)(pBlitImageInfo));
}
vk->vkCmdBlitImage2KHR((VkCommandBuffer)dispatchHandle, pBlitImageInfo);
android::base::endTrace();
@@ -2287,15 +2797,15 @@
}
case OP_vkCmdResolveImage2KHR: {
android::base::beginTrace("vkCmdResolveImage2KHR subdecode");
- const VkResolveImageInfo2KHR* pResolveImageInfo;
- VkResolveImageInfo2KHR stack_pResolveImageInfo[1];
- pResolveImageInfo = (VkResolveImageInfo2KHR*)stack_pResolveImageInfo;
- reservedunmarshal_VkResolveImageInfo2KHR(
- readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
- (VkResolveImageInfo2KHR*)(pResolveImageInfo), readStreamPtrPtr);
+ const VkResolveImageInfo2* pResolveImageInfo;
+ VkResolveImageInfo2 stack_pResolveImageInfo[1];
+ pResolveImageInfo = (VkResolveImageInfo2*)stack_pResolveImageInfo;
+ reservedunmarshal_VkResolveImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkResolveImageInfo2*)(pResolveImageInfo),
+ readStreamPtrPtr);
if (pResolveImageInfo) {
- transform_tohost_VkResolveImageInfo2KHR(
- globalstate, (VkResolveImageInfo2KHR*)(pResolveImageInfo));
+ transform_tohost_VkResolveImageInfo2(globalstate,
+ (VkResolveImageInfo2*)(pResolveImageInfo));
}
vk->vkCmdResolveImage2KHR((VkCommandBuffer)dispatchHandle, pResolveImageInfo);
android::base::endTrace();
@@ -2304,8 +2814,25 @@
#endif
#ifdef VK_KHR_format_feature_flags2
#endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+ case OP_vkCmdTraceRaysIndirect2KHR: {
+ android::base::beginTrace("vkCmdTraceRaysIndirect2KHR subdecode");
+ VkDeviceAddress indirectDeviceAddress;
+ memcpy((VkDeviceAddress*)&indirectDeviceAddress, *readStreamPtrPtr,
+ sizeof(VkDeviceAddress));
+ *readStreamPtrPtr += sizeof(VkDeviceAddress);
+ vk->vkCmdTraceRaysIndirect2KHR((VkCommandBuffer)dispatchHandle,
+ indirectDeviceAddress);
+ android::base::endTrace();
+ break;
+ }
+#endif
+#ifdef VK_KHR_portability_enumeration
+#endif
#ifdef VK_KHR_maintenance4
#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+#endif
#ifdef VK_ANDROID_native_buffer
#endif
#ifdef VK_EXT_debug_report
@@ -2698,8 +3225,6 @@
#endif
#ifdef VK_EXT_video_encode_h265
#endif
-#ifdef VK_EXT_video_decode_h264
-#endif
#ifdef VK_AMD_texture_gather_bias_lod
#endif
#ifdef VK_AMD_shader_info
@@ -2732,6 +3257,8 @@
#endif
#ifdef VK_EXT_astc_decode_mode
#endif
+#ifdef VK_EXT_pipeline_robustness
+#endif
#ifdef VK_EXT_conditional_rendering
case OP_vkCmdBeginConditionalRenderingEXT: {
android::base::beginTrace("vkCmdBeginConditionalRenderingEXT subdecode");
@@ -2847,6 +3374,27 @@
android::base::endTrace();
break;
}
+ case OP_vkCmdSetDiscardRectangleEnableEXT: {
+ android::base::beginTrace("vkCmdSetDiscardRectangleEnableEXT subdecode");
+ VkBool32 discardRectangleEnable;
+ memcpy((VkBool32*)&discardRectangleEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetDiscardRectangleEnableEXT((VkCommandBuffer)dispatchHandle,
+ discardRectangleEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetDiscardRectangleModeEXT: {
+ android::base::beginTrace("vkCmdSetDiscardRectangleModeEXT subdecode");
+ VkDiscardRectangleModeEXT discardRectangleMode;
+ memcpy((VkDiscardRectangleModeEXT*)&discardRectangleMode, *readStreamPtrPtr,
+ sizeof(VkDiscardRectangleModeEXT));
+ *readStreamPtrPtr += sizeof(VkDiscardRectangleModeEXT);
+ vk->vkCmdSetDiscardRectangleModeEXT((VkCommandBuffer)dispatchHandle,
+ discardRectangleMode);
+ android::base::endTrace();
+ break;
+ }
#endif
#ifdef VK_EXT_conservative_rasterization
#endif
@@ -2860,8 +3408,6 @@
#endif
#ifdef VK_MVK_macos_surface
#endif
-#ifdef VK_MVK_moltenvk
-#endif
#ifdef VK_EXT_external_memory_dma_buf
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -3279,8 +3825,6 @@
#endif
#ifdef VK_AMD_shader_core_properties
#endif
-#ifdef VK_EXT_video_decode_h265
-#endif
#ifdef VK_AMD_memory_overallocation_behavior
#endif
#ifdef VK_EXT_vertex_attribute_divisor
@@ -3363,6 +3907,31 @@
#ifdef VK_NV_shader_image_footprint
#endif
#ifdef VK_NV_scissor_exclusive
+ case OP_vkCmdSetExclusiveScissorEnableNV: {
+ android::base::beginTrace("vkCmdSetExclusiveScissorEnableNV subdecode");
+ uint32_t firstExclusiveScissor;
+ uint32_t exclusiveScissorCount;
+ const VkBool32* pExclusiveScissorEnables;
+ VkBool32 stack_pExclusiveScissorEnables[MAX_STACK_ITEMS];
+ memcpy((uint32_t*)&firstExclusiveScissor, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&exclusiveScissorCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (((exclusiveScissorCount)) <= MAX_STACK_ITEMS) {
+ pExclusiveScissorEnables = (VkBool32*)stack_pExclusiveScissorEnables;
+ } else {
+ readStream->alloc((void**)&pExclusiveScissorEnables,
+ ((exclusiveScissorCount)) * sizeof(const VkBool32));
+ }
+ memcpy((VkBool32*)pExclusiveScissorEnables, *readStreamPtrPtr,
+ ((exclusiveScissorCount)) * sizeof(const VkBool32));
+ *readStreamPtrPtr += ((exclusiveScissorCount)) * sizeof(const VkBool32);
+ vk->vkCmdSetExclusiveScissorEnableNV((VkCommandBuffer)dispatchHandle,
+ firstExclusiveScissor, exclusiveScissorCount,
+ pExclusiveScissorEnables);
+ android::base::endTrace();
+ break;
+ }
case OP_vkCmdSetExclusiveScissorNV: {
android::base::beginTrace("vkCmdSetExclusiveScissorNV subdecode");
uint32_t firstExclusiveScissor;
@@ -3799,6 +4368,10 @@
#endif
#ifdef VK_EXT_shader_atomic_float2
#endif
+#ifdef VK_EXT_surface_maintenance1
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
#endif
#ifdef VK_NV_device_generated_commands
@@ -3875,6 +4448,8 @@
#endif
#ifdef VK_GOOGLE_user_type
#endif
+#ifdef VK_NV_present_barrier
+#endif
#ifdef VK_EXT_private_data
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
@@ -3883,6 +4458,111 @@
#endif
#ifdef VK_QCOM_render_pass_store_ops
#endif
+#ifdef VK_NV_low_latency
+#endif
+#ifdef VK_EXT_metal_objects
+#endif
+#ifdef VK_EXT_descriptor_buffer
+ case OP_vkCmdBindDescriptorBuffersEXT: {
+ android::base::beginTrace("vkCmdBindDescriptorBuffersEXT subdecode");
+ uint32_t bufferCount;
+ const VkDescriptorBufferBindingInfoEXT* pBindingInfos;
+ VkDescriptorBufferBindingInfoEXT stack_pBindingInfos[MAX_STACK_ITEMS];
+ memcpy((uint32_t*)&bufferCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (((bufferCount)) <= MAX_STACK_ITEMS) {
+ pBindingInfos = (VkDescriptorBufferBindingInfoEXT*)stack_pBindingInfos;
+ } else {
+ readStream->alloc(
+ (void**)&pBindingInfos,
+ ((bufferCount)) * sizeof(const VkDescriptorBufferBindingInfoEXT));
+ }
+ for (uint32_t i = 0; i < (uint32_t)((bufferCount)); ++i) {
+ reservedunmarshal_VkDescriptorBufferBindingInfoEXT(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorBufferBindingInfoEXT*)(pBindingInfos + i), readStreamPtrPtr);
+ }
+ if (pBindingInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((bufferCount)); ++i) {
+ transform_tohost_VkDescriptorBufferBindingInfoEXT(
+ globalstate, (VkDescriptorBufferBindingInfoEXT*)(pBindingInfos + i));
+ }
+ }
+ vk->vkCmdBindDescriptorBuffersEXT((VkCommandBuffer)dispatchHandle, bufferCount,
+ pBindingInfos);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetDescriptorBufferOffsetsEXT: {
+ android::base::beginTrace("vkCmdSetDescriptorBufferOffsetsEXT subdecode");
+ VkPipelineBindPoint pipelineBindPoint;
+ VkPipelineLayout layout;
+ uint32_t firstSet;
+ uint32_t setCount;
+ const uint32_t* pBufferIndices;
+ uint32_t stack_pBufferIndices[MAX_STACK_ITEMS];
+ const VkDeviceSize* pOffsets;
+ VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
+ memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
+ sizeof(VkPipelineBindPoint));
+ *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkPipelineLayout*)&layout =
+ (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
+ memcpy((uint32_t*)&firstSet, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&setCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (((setCount)) <= MAX_STACK_ITEMS) {
+ pBufferIndices = (uint32_t*)stack_pBufferIndices;
+ } else {
+ readStream->alloc((void**)&pBufferIndices,
+ ((setCount)) * sizeof(const uint32_t));
+ }
+ memcpy((uint32_t*)pBufferIndices, *readStreamPtrPtr,
+ ((setCount)) * sizeof(const uint32_t));
+ *readStreamPtrPtr += ((setCount)) * sizeof(const uint32_t);
+ if (((setCount)) <= MAX_STACK_ITEMS) {
+ pOffsets = (VkDeviceSize*)stack_pOffsets;
+ } else {
+ readStream->alloc((void**)&pOffsets, ((setCount)) * sizeof(const VkDeviceSize));
+ }
+ memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
+ ((setCount)) * sizeof(const VkDeviceSize));
+ *readStreamPtrPtr += ((setCount)) * sizeof(const VkDeviceSize);
+ vk->vkCmdSetDescriptorBufferOffsetsEXT((VkCommandBuffer)dispatchHandle,
+ pipelineBindPoint, layout, firstSet,
+ setCount, pBufferIndices, pOffsets);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdBindDescriptorBufferEmbeddedSamplersEXT: {
+ android::base::beginTrace("vkCmdBindDescriptorBufferEmbeddedSamplersEXT subdecode");
+ VkPipelineBindPoint pipelineBindPoint;
+ VkPipelineLayout layout;
+ uint32_t set;
+ memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
+ sizeof(VkPipelineBindPoint));
+ *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkPipelineLayout*)&layout =
+ (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
+ memcpy((uint32_t*)&set, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ vk->vkCmdBindDescriptorBufferEmbeddedSamplersEXT((VkCommandBuffer)dispatchHandle,
+ pipelineBindPoint, layout, set);
+ android::base::endTrace();
+ break;
+ }
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+#endif
#ifdef VK_NV_fragment_shading_rate_enums
case OP_vkCmdSetFragmentShadingRateEnumNV: {
android::base::beginTrace("vkCmdSetFragmentShadingRateEnumNV subdecode");
@@ -3910,8 +4590,16 @@
#endif
#ifdef VK_EXT_image_robustness
#endif
+#ifdef VK_EXT_image_compression_control
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+#endif
#ifdef VK_EXT_4444_formats
#endif
+#ifdef VK_EXT_device_fault
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+#endif
#ifdef VK_EXT_rgba10x6_formats
#endif
#ifdef VK_NV_acquire_winrt_display
@@ -3990,6 +4678,10 @@
#endif
#ifdef VK_EXT_physical_device_drm
#endif
+#ifdef VK_EXT_device_address_binding_report
+#endif
+#ifdef VK_EXT_depth_clip_control
+#endif
#ifdef VK_EXT_primitive_topology_list_restart
#endif
#ifdef VK_FUCHSIA_external_memory
@@ -4026,6 +4718,10 @@
#endif
#ifdef VK_NV_external_memory_rdma
#endif
+#ifdef VK_EXT_pipeline_properties
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+#endif
#ifdef VK_EXT_extended_dynamic_state2
case OP_vkCmdSetPatchControlPointsEXT: {
android::base::beginTrace("vkCmdSetPatchControlPointsEXT subdecode");
@@ -4101,6 +4797,8 @@
break;
}
#endif
+#ifdef VK_EXT_primitives_generated_query
+#endif
#ifdef VK_GOOGLE_gfxstream
case OP_vkBeginCommandBufferAsyncGOOGLE: {
android::base::beginTrace("vkBeginCommandBufferAsyncGOOGLE subdecode");
@@ -4153,6 +4851,8 @@
#endif
#ifdef VK_EXT_global_priority_query
#endif
+#ifdef VK_EXT_image_view_min_lod
+#endif
#ifdef VK_EXT_multi_draw
case OP_vkCmdDrawMultiEXT: {
android::base::beginTrace("vkCmdDrawMultiEXT subdecode");
@@ -4254,12 +4954,848 @@
break;
}
#endif
+#ifdef VK_EXT_image_2d_view_of_3d
+#endif
+#ifdef VK_EXT_shader_tile_image
+#endif
+#ifdef VK_EXT_opacity_micromap
+ case OP_vkCmdBuildMicromapsEXT: {
+ android::base::beginTrace("vkCmdBuildMicromapsEXT subdecode");
+ uint32_t infoCount;
+ const VkMicromapBuildInfoEXT* pInfos;
+ VkMicromapBuildInfoEXT stack_pInfos[MAX_STACK_ITEMS];
+ memcpy((uint32_t*)&infoCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (((infoCount)) <= MAX_STACK_ITEMS) {
+ pInfos = (VkMicromapBuildInfoEXT*)stack_pInfos;
+ } else {
+ readStream->alloc((void**)&pInfos,
+ ((infoCount)) * sizeof(const VkMicromapBuildInfoEXT));
+ }
+ for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+ reservedunmarshal_VkMicromapBuildInfoEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMicromapBuildInfoEXT*)(pInfos + i),
+ readStreamPtrPtr);
+ }
+ if (pInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+ transform_tohost_VkMicromapBuildInfoEXT(
+ globalstate, (VkMicromapBuildInfoEXT*)(pInfos + i));
+ }
+ }
+ vk->vkCmdBuildMicromapsEXT((VkCommandBuffer)dispatchHandle, infoCount, pInfos);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdCopyMicromapEXT: {
+ android::base::beginTrace("vkCmdCopyMicromapEXT subdecode");
+ const VkCopyMicromapInfoEXT* pInfo;
+ VkCopyMicromapInfoEXT stack_pInfo[1];
+ pInfo = (VkCopyMicromapInfoEXT*)stack_pInfo;
+ reservedunmarshal_VkCopyMicromapInfoEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyMicromapInfoEXT*)(pInfo),
+ readStreamPtrPtr);
+ if (pInfo) {
+ transform_tohost_VkCopyMicromapInfoEXT(globalstate,
+ (VkCopyMicromapInfoEXT*)(pInfo));
+ }
+ vk->vkCmdCopyMicromapEXT((VkCommandBuffer)dispatchHandle, pInfo);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdCopyMicromapToMemoryEXT: {
+ android::base::beginTrace("vkCmdCopyMicromapToMemoryEXT subdecode");
+ const VkCopyMicromapToMemoryInfoEXT* pInfo;
+ VkCopyMicromapToMemoryInfoEXT stack_pInfo[1];
+ pInfo = (VkCopyMicromapToMemoryInfoEXT*)stack_pInfo;
+ reservedunmarshal_VkCopyMicromapToMemoryInfoEXT(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyMicromapToMemoryInfoEXT*)(pInfo),
+ readStreamPtrPtr);
+ if (pInfo) {
+ transform_tohost_VkCopyMicromapToMemoryInfoEXT(
+ globalstate, (VkCopyMicromapToMemoryInfoEXT*)(pInfo));
+ }
+ vk->vkCmdCopyMicromapToMemoryEXT((VkCommandBuffer)dispatchHandle, pInfo);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdCopyMemoryToMicromapEXT: {
+ android::base::beginTrace("vkCmdCopyMemoryToMicromapEXT subdecode");
+ const VkCopyMemoryToMicromapInfoEXT* pInfo;
+ VkCopyMemoryToMicromapInfoEXT stack_pInfo[1];
+ pInfo = (VkCopyMemoryToMicromapInfoEXT*)stack_pInfo;
+ reservedunmarshal_VkCopyMemoryToMicromapInfoEXT(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyMemoryToMicromapInfoEXT*)(pInfo),
+ readStreamPtrPtr);
+ if (pInfo) {
+ transform_tohost_VkCopyMemoryToMicromapInfoEXT(
+ globalstate, (VkCopyMemoryToMicromapInfoEXT*)(pInfo));
+ }
+ vk->vkCmdCopyMemoryToMicromapEXT((VkCommandBuffer)dispatchHandle, pInfo);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdWriteMicromapsPropertiesEXT: {
+ android::base::beginTrace("vkCmdWriteMicromapsPropertiesEXT subdecode");
+ uint32_t micromapCount;
+ const VkMicromapEXT* pMicromaps;
+ VkMicromapEXT stack_pMicromaps[MAX_STACK_ITEMS];
+ VkQueryType queryType;
+ VkQueryPool queryPool;
+ uint32_t firstQuery;
+ memcpy((uint32_t*)µmapCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (((micromapCount)) <= MAX_STACK_ITEMS) {
+ pMicromaps = (VkMicromapEXT*)stack_pMicromaps;
+ } else {
+ readStream->alloc((void**)&pMicromaps,
+ ((micromapCount)) * sizeof(const VkMicromapEXT));
+ }
+ for (uint32_t i = 0; i < (uint32_t)((micromapCount)); ++i) {
+ memcpy((VkMicromapEXT*)&pMicromaps[i], (*readStreamPtrPtr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&pMicromaps[i]);
+ *readStreamPtrPtr += 8;
+ }
+ memcpy((VkQueryType*)&queryType, *readStreamPtrPtr, sizeof(VkQueryType));
+ *readStreamPtrPtr += sizeof(VkQueryType);
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkQueryPool*)&queryPool =
+ (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
+ memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ vk->vkCmdWriteMicromapsPropertiesEXT((VkCommandBuffer)dispatchHandle, micromapCount,
+ pMicromaps, queryType, queryPool, firstQuery);
+ android::base::endTrace();
+ break;
+ }
+#endif
+#ifdef VK_NV_displacement_micromap
+#endif
#ifdef VK_EXT_load_store_op_none
#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+ case OP_vkCmdDrawClusterHUAWEI: {
+ android::base::beginTrace("vkCmdDrawClusterHUAWEI subdecode");
+ uint32_t groupCountX;
+ uint32_t groupCountY;
+ uint32_t groupCountZ;
+ memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ vk->vkCmdDrawClusterHUAWEI((VkCommandBuffer)dispatchHandle, groupCountX,
+ groupCountY, groupCountZ);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdDrawClusterIndirectHUAWEI: {
+ android::base::beginTrace("vkCmdDrawClusterIndirectHUAWEI subdecode");
+ VkBuffer buffer;
+ VkDeviceSize offset;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+ memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+ *readStreamPtrPtr += sizeof(VkDeviceSize);
+ vk->vkCmdDrawClusterIndirectHUAWEI((VkCommandBuffer)dispatchHandle, buffer, offset);
+ android::base::endTrace();
+ break;
+ }
+#endif
#ifdef VK_EXT_border_color_swizzle
#endif
#ifdef VK_EXT_pageable_device_local_memory
#endif
+#ifdef VK_ARM_shader_core_properties
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+#endif
+#ifdef VK_NV_copy_memory_indirect
+ case OP_vkCmdCopyMemoryIndirectNV: {
+ android::base::beginTrace("vkCmdCopyMemoryIndirectNV subdecode");
+ VkDeviceAddress copyBufferAddress;
+ uint32_t copyCount;
+ uint32_t stride;
+ memcpy((VkDeviceAddress*)©BufferAddress, *readStreamPtrPtr,
+ sizeof(VkDeviceAddress));
+ *readStreamPtrPtr += sizeof(VkDeviceAddress);
+ memcpy((uint32_t*)©Count, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ vk->vkCmdCopyMemoryIndirectNV((VkCommandBuffer)dispatchHandle, copyBufferAddress,
+ copyCount, stride);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdCopyMemoryToImageIndirectNV: {
+ android::base::beginTrace("vkCmdCopyMemoryToImageIndirectNV subdecode");
+ VkDeviceAddress copyBufferAddress;
+ uint32_t copyCount;
+ uint32_t stride;
+ VkImage dstImage;
+ VkImageLayout dstImageLayout;
+ const VkImageSubresourceLayers* pImageSubresources;
+ VkImageSubresourceLayers stack_pImageSubresources[MAX_STACK_ITEMS];
+ memcpy((VkDeviceAddress*)©BufferAddress, *readStreamPtrPtr,
+ sizeof(VkDeviceAddress));
+ *readStreamPtrPtr += sizeof(VkDeviceAddress);
+ memcpy((uint32_t*)©Count, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
+ memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
+ *readStreamPtrPtr += sizeof(VkImageLayout);
+ if (((copyCount)) <= MAX_STACK_ITEMS) {
+ pImageSubresources = (VkImageSubresourceLayers*)stack_pImageSubresources;
+ } else {
+ readStream->alloc((void**)&pImageSubresources,
+ ((copyCount)) * sizeof(const VkImageSubresourceLayers));
+ }
+ for (uint32_t i = 0; i < (uint32_t)((copyCount)); ++i) {
+ reservedunmarshal_VkImageSubresourceLayers(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageSubresourceLayers*)(pImageSubresources + i), readStreamPtrPtr);
+ }
+ if (pImageSubresources) {
+ for (uint32_t i = 0; i < (uint32_t)((copyCount)); ++i) {
+ transform_tohost_VkImageSubresourceLayers(
+ globalstate, (VkImageSubresourceLayers*)(pImageSubresources + i));
+ }
+ }
+ vk->vkCmdCopyMemoryToImageIndirectNV((VkCommandBuffer)dispatchHandle,
+ copyBufferAddress, copyCount, stride, dstImage,
+ dstImageLayout, pImageSubresources);
+ android::base::endTrace();
+ break;
+ }
+#endif
+#ifdef VK_NV_memory_decompression
+ case OP_vkCmdDecompressMemoryNV: {
+ android::base::beginTrace("vkCmdDecompressMemoryNV subdecode");
+ uint32_t decompressRegionCount;
+ const VkDecompressMemoryRegionNV* pDecompressMemoryRegions;
+ VkDecompressMemoryRegionNV stack_pDecompressMemoryRegions[MAX_STACK_ITEMS];
+ memcpy((uint32_t*)&decompressRegionCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (((decompressRegionCount)) <= MAX_STACK_ITEMS) {
+ pDecompressMemoryRegions =
+ (VkDecompressMemoryRegionNV*)stack_pDecompressMemoryRegions;
+ } else {
+ readStream->alloc(
+ (void**)&pDecompressMemoryRegions,
+ ((decompressRegionCount)) * sizeof(const VkDecompressMemoryRegionNV));
+ }
+ for (uint32_t i = 0; i < (uint32_t)((decompressRegionCount)); ++i) {
+ reservedunmarshal_VkDecompressMemoryRegionNV(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDecompressMemoryRegionNV*)(pDecompressMemoryRegions + i),
+ readStreamPtrPtr);
+ }
+ if (pDecompressMemoryRegions) {
+ for (uint32_t i = 0; i < (uint32_t)((decompressRegionCount)); ++i) {
+ transform_tohost_VkDecompressMemoryRegionNV(
+ globalstate,
+ (VkDecompressMemoryRegionNV*)(pDecompressMemoryRegions + i));
+ }
+ }
+ vk->vkCmdDecompressMemoryNV((VkCommandBuffer)dispatchHandle, decompressRegionCount,
+ pDecompressMemoryRegions);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdDecompressMemoryIndirectCountNV: {
+ android::base::beginTrace("vkCmdDecompressMemoryIndirectCountNV subdecode");
+ VkDeviceAddress indirectCommandsAddress;
+ VkDeviceAddress indirectCommandsCountAddress;
+ uint32_t stride;
+ memcpy((VkDeviceAddress*)&indirectCommandsAddress, *readStreamPtrPtr,
+ sizeof(VkDeviceAddress));
+ *readStreamPtrPtr += sizeof(VkDeviceAddress);
+ memcpy((VkDeviceAddress*)&indirectCommandsCountAddress, *readStreamPtrPtr,
+ sizeof(VkDeviceAddress));
+ *readStreamPtrPtr += sizeof(VkDeviceAddress);
+ memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ vk->vkCmdDecompressMemoryIndirectCountNV((VkCommandBuffer)dispatchHandle,
+ indirectCommandsAddress,
+ indirectCommandsCountAddress, stride);
+ android::base::endTrace();
+ break;
+ }
+#endif
+#ifdef VK_NV_linear_color_attachment
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+#endif
+#ifdef VK_QCOM_image_processing
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+ case OP_vkCmdSetTessellationDomainOriginEXT: {
+ android::base::beginTrace("vkCmdSetTessellationDomainOriginEXT subdecode");
+ VkTessellationDomainOrigin domainOrigin;
+ memcpy((VkTessellationDomainOrigin*)&domainOrigin, *readStreamPtrPtr,
+ sizeof(VkTessellationDomainOrigin));
+ *readStreamPtrPtr += sizeof(VkTessellationDomainOrigin);
+ vk->vkCmdSetTessellationDomainOriginEXT((VkCommandBuffer)dispatchHandle,
+ domainOrigin);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetDepthClampEnableEXT: {
+ android::base::beginTrace("vkCmdSetDepthClampEnableEXT subdecode");
+ VkBool32 depthClampEnable;
+ memcpy((VkBool32*)&depthClampEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetDepthClampEnableEXT((VkCommandBuffer)dispatchHandle, depthClampEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetPolygonModeEXT: {
+ android::base::beginTrace("vkCmdSetPolygonModeEXT subdecode");
+ VkPolygonMode polygonMode;
+ memcpy((VkPolygonMode*)&polygonMode, *readStreamPtrPtr, sizeof(VkPolygonMode));
+ *readStreamPtrPtr += sizeof(VkPolygonMode);
+ vk->vkCmdSetPolygonModeEXT((VkCommandBuffer)dispatchHandle, polygonMode);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetRasterizationSamplesEXT: {
+ android::base::beginTrace("vkCmdSetRasterizationSamplesEXT subdecode");
+ VkSampleCountFlagBits rasterizationSamples;
+ memcpy((VkSampleCountFlagBits*)&rasterizationSamples, *readStreamPtrPtr,
+ sizeof(VkSampleCountFlagBits));
+ *readStreamPtrPtr += sizeof(VkSampleCountFlagBits);
+ vk->vkCmdSetRasterizationSamplesEXT((VkCommandBuffer)dispatchHandle,
+ rasterizationSamples);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetSampleMaskEXT: {
+ android::base::beginTrace("vkCmdSetSampleMaskEXT subdecode");
+ VkSampleCountFlagBits samples;
+ const VkSampleMask* pSampleMask;
+ VkSampleMask stack_pSampleMask[MAX_STACK_ITEMS];
+ memcpy((VkSampleCountFlagBits*)&samples, *readStreamPtrPtr,
+ sizeof(VkSampleCountFlagBits));
+ *readStreamPtrPtr += sizeof(VkSampleCountFlagBits);
+ if (int(samples / 32) <= MAX_STACK_ITEMS) {
+ pSampleMask = (VkSampleMask*)stack_pSampleMask;
+ } else {
+ readStream->alloc((void**)&pSampleMask,
+ int(samples / 32) * sizeof(const VkSampleMask));
+ }
+ memcpy((VkSampleMask*)pSampleMask, *readStreamPtrPtr,
+ int(samples / 32) * sizeof(const VkSampleMask));
+ *readStreamPtrPtr += int(samples / 32) * sizeof(const VkSampleMask);
+ vk->vkCmdSetSampleMaskEXT((VkCommandBuffer)dispatchHandle, samples, pSampleMask);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetAlphaToCoverageEnableEXT: {
+ android::base::beginTrace("vkCmdSetAlphaToCoverageEnableEXT subdecode");
+ VkBool32 alphaToCoverageEnable;
+ memcpy((VkBool32*)&alphaToCoverageEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetAlphaToCoverageEnableEXT((VkCommandBuffer)dispatchHandle,
+ alphaToCoverageEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetAlphaToOneEnableEXT: {
+ android::base::beginTrace("vkCmdSetAlphaToOneEnableEXT subdecode");
+ VkBool32 alphaToOneEnable;
+ memcpy((VkBool32*)&alphaToOneEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetAlphaToOneEnableEXT((VkCommandBuffer)dispatchHandle, alphaToOneEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetLogicOpEnableEXT: {
+ android::base::beginTrace("vkCmdSetLogicOpEnableEXT subdecode");
+ VkBool32 logicOpEnable;
+ memcpy((VkBool32*)&logicOpEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetLogicOpEnableEXT((VkCommandBuffer)dispatchHandle, logicOpEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetColorBlendEnableEXT: {
+ android::base::beginTrace("vkCmdSetColorBlendEnableEXT subdecode");
+ uint32_t firstAttachment;
+ uint32_t attachmentCount;
+ const VkBool32* pColorBlendEnables;
+ VkBool32 stack_pColorBlendEnables[MAX_STACK_ITEMS];
+ memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (((attachmentCount)) <= MAX_STACK_ITEMS) {
+ pColorBlendEnables = (VkBool32*)stack_pColorBlendEnables;
+ } else {
+ readStream->alloc((void**)&pColorBlendEnables,
+ ((attachmentCount)) * sizeof(const VkBool32));
+ }
+ memcpy((VkBool32*)pColorBlendEnables, *readStreamPtrPtr,
+ ((attachmentCount)) * sizeof(const VkBool32));
+ *readStreamPtrPtr += ((attachmentCount)) * sizeof(const VkBool32);
+ vk->vkCmdSetColorBlendEnableEXT((VkCommandBuffer)dispatchHandle, firstAttachment,
+ attachmentCount, pColorBlendEnables);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetColorBlendEquationEXT: {
+ android::base::beginTrace("vkCmdSetColorBlendEquationEXT subdecode");
+ uint32_t firstAttachment;
+ uint32_t attachmentCount;
+ const VkColorBlendEquationEXT* pColorBlendEquations;
+ VkColorBlendEquationEXT stack_pColorBlendEquations[MAX_STACK_ITEMS];
+ memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (((attachmentCount)) <= MAX_STACK_ITEMS) {
+ pColorBlendEquations = (VkColorBlendEquationEXT*)stack_pColorBlendEquations;
+ } else {
+ readStream->alloc((void**)&pColorBlendEquations,
+ ((attachmentCount)) * sizeof(const VkColorBlendEquationEXT));
+ }
+ for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+ reservedunmarshal_VkColorBlendEquationEXT(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkColorBlendEquationEXT*)(pColorBlendEquations + i), readStreamPtrPtr);
+ }
+ if (pColorBlendEquations) {
+ for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+ transform_tohost_VkColorBlendEquationEXT(
+ globalstate, (VkColorBlendEquationEXT*)(pColorBlendEquations + i));
+ }
+ }
+ vk->vkCmdSetColorBlendEquationEXT((VkCommandBuffer)dispatchHandle, firstAttachment,
+ attachmentCount, pColorBlendEquations);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetColorWriteMaskEXT: {
+ android::base::beginTrace("vkCmdSetColorWriteMaskEXT subdecode");
+ uint32_t firstAttachment;
+ uint32_t attachmentCount;
+ const VkColorComponentFlags* pColorWriteMasks;
+ VkColorComponentFlags stack_pColorWriteMasks[MAX_STACK_ITEMS];
+ memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ memcpy((VkColorComponentFlags**)&pColorWriteMasks, (*readStreamPtrPtr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&pColorWriteMasks);
+ *readStreamPtrPtr += 8;
+ if (pColorWriteMasks) {
+ if (((attachmentCount)) <= MAX_STACK_ITEMS) {
+ pColorWriteMasks = (VkColorComponentFlags*)stack_pColorWriteMasks;
+ } else {
+ readStream->alloc(
+ (void**)&pColorWriteMasks,
+ ((attachmentCount)) * sizeof(const VkColorComponentFlags));
+ }
+ memcpy((VkColorComponentFlags*)pColorWriteMasks, *readStreamPtrPtr,
+ ((attachmentCount)) * sizeof(const VkColorComponentFlags));
+ *readStreamPtrPtr += ((attachmentCount)) * sizeof(const VkColorComponentFlags);
+ }
+ vk->vkCmdSetColorWriteMaskEXT((VkCommandBuffer)dispatchHandle, firstAttachment,
+ attachmentCount, pColorWriteMasks);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetRasterizationStreamEXT: {
+ android::base::beginTrace("vkCmdSetRasterizationStreamEXT subdecode");
+ uint32_t rasterizationStream;
+ memcpy((uint32_t*)&rasterizationStream, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ vk->vkCmdSetRasterizationStreamEXT((VkCommandBuffer)dispatchHandle,
+ rasterizationStream);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetConservativeRasterizationModeEXT: {
+ android::base::beginTrace("vkCmdSetConservativeRasterizationModeEXT subdecode");
+ VkConservativeRasterizationModeEXT conservativeRasterizationMode;
+ memcpy((VkConservativeRasterizationModeEXT*)&conservativeRasterizationMode,
+ *readStreamPtrPtr, sizeof(VkConservativeRasterizationModeEXT));
+ *readStreamPtrPtr += sizeof(VkConservativeRasterizationModeEXT);
+ vk->vkCmdSetConservativeRasterizationModeEXT((VkCommandBuffer)dispatchHandle,
+ conservativeRasterizationMode);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetExtraPrimitiveOverestimationSizeEXT: {
+ android::base::beginTrace("vkCmdSetExtraPrimitiveOverestimationSizeEXT subdecode");
+ float extraPrimitiveOverestimationSize;
+ memcpy((float*)&extraPrimitiveOverestimationSize, *readStreamPtrPtr, sizeof(float));
+ *readStreamPtrPtr += sizeof(float);
+ vk->vkCmdSetExtraPrimitiveOverestimationSizeEXT((VkCommandBuffer)dispatchHandle,
+ extraPrimitiveOverestimationSize);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetDepthClipEnableEXT: {
+ android::base::beginTrace("vkCmdSetDepthClipEnableEXT subdecode");
+ VkBool32 depthClipEnable;
+ memcpy((VkBool32*)&depthClipEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetDepthClipEnableEXT((VkCommandBuffer)dispatchHandle, depthClipEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetSampleLocationsEnableEXT: {
+ android::base::beginTrace("vkCmdSetSampleLocationsEnableEXT subdecode");
+ VkBool32 sampleLocationsEnable;
+ memcpy((VkBool32*)&sampleLocationsEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetSampleLocationsEnableEXT((VkCommandBuffer)dispatchHandle,
+ sampleLocationsEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetColorBlendAdvancedEXT: {
+ android::base::beginTrace("vkCmdSetColorBlendAdvancedEXT subdecode");
+ uint32_t firstAttachment;
+ uint32_t attachmentCount;
+ const VkColorBlendAdvancedEXT* pColorBlendAdvanced;
+ VkColorBlendAdvancedEXT stack_pColorBlendAdvanced[MAX_STACK_ITEMS];
+ memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (((attachmentCount)) <= MAX_STACK_ITEMS) {
+ pColorBlendAdvanced = (VkColorBlendAdvancedEXT*)stack_pColorBlendAdvanced;
+ } else {
+ readStream->alloc((void**)&pColorBlendAdvanced,
+ ((attachmentCount)) * sizeof(const VkColorBlendAdvancedEXT));
+ }
+ for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+ reservedunmarshal_VkColorBlendAdvancedEXT(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkColorBlendAdvancedEXT*)(pColorBlendAdvanced + i), readStreamPtrPtr);
+ }
+ if (pColorBlendAdvanced) {
+ for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+ transform_tohost_VkColorBlendAdvancedEXT(
+ globalstate, (VkColorBlendAdvancedEXT*)(pColorBlendAdvanced + i));
+ }
+ }
+ vk->vkCmdSetColorBlendAdvancedEXT((VkCommandBuffer)dispatchHandle, firstAttachment,
+ attachmentCount, pColorBlendAdvanced);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetProvokingVertexModeEXT: {
+ android::base::beginTrace("vkCmdSetProvokingVertexModeEXT subdecode");
+ VkProvokingVertexModeEXT provokingVertexMode;
+ memcpy((VkProvokingVertexModeEXT*)&provokingVertexMode, *readStreamPtrPtr,
+ sizeof(VkProvokingVertexModeEXT));
+ *readStreamPtrPtr += sizeof(VkProvokingVertexModeEXT);
+ vk->vkCmdSetProvokingVertexModeEXT((VkCommandBuffer)dispatchHandle,
+ provokingVertexMode);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetLineRasterizationModeEXT: {
+ android::base::beginTrace("vkCmdSetLineRasterizationModeEXT subdecode");
+ VkLineRasterizationModeEXT lineRasterizationMode;
+ memcpy((VkLineRasterizationModeEXT*)&lineRasterizationMode, *readStreamPtrPtr,
+ sizeof(VkLineRasterizationModeEXT));
+ *readStreamPtrPtr += sizeof(VkLineRasterizationModeEXT);
+ vk->vkCmdSetLineRasterizationModeEXT((VkCommandBuffer)dispatchHandle,
+ lineRasterizationMode);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetLineStippleEnableEXT: {
+ android::base::beginTrace("vkCmdSetLineStippleEnableEXT subdecode");
+ VkBool32 stippledLineEnable;
+ memcpy((VkBool32*)&stippledLineEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetLineStippleEnableEXT((VkCommandBuffer)dispatchHandle,
+ stippledLineEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetDepthClipNegativeOneToOneEXT: {
+ android::base::beginTrace("vkCmdSetDepthClipNegativeOneToOneEXT subdecode");
+ VkBool32 negativeOneToOne;
+ memcpy((VkBool32*)&negativeOneToOne, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetDepthClipNegativeOneToOneEXT((VkCommandBuffer)dispatchHandle,
+ negativeOneToOne);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetViewportWScalingEnableNV: {
+ android::base::beginTrace("vkCmdSetViewportWScalingEnableNV subdecode");
+ VkBool32 viewportWScalingEnable;
+ memcpy((VkBool32*)&viewportWScalingEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetViewportWScalingEnableNV((VkCommandBuffer)dispatchHandle,
+ viewportWScalingEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetViewportSwizzleNV: {
+ android::base::beginTrace("vkCmdSetViewportSwizzleNV subdecode");
+ uint32_t firstViewport;
+ uint32_t viewportCount;
+ const VkViewportSwizzleNV* pViewportSwizzles;
+ VkViewportSwizzleNV stack_pViewportSwizzles[MAX_STACK_ITEMS];
+ memcpy((uint32_t*)&firstViewport, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (((viewportCount)) <= MAX_STACK_ITEMS) {
+ pViewportSwizzles = (VkViewportSwizzleNV*)stack_pViewportSwizzles;
+ } else {
+ readStream->alloc((void**)&pViewportSwizzles,
+ ((viewportCount)) * sizeof(const VkViewportSwizzleNV));
+ }
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ reservedunmarshal_VkViewportSwizzleNV(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkViewportSwizzleNV*)(pViewportSwizzles + i), readStreamPtrPtr);
+ }
+ if (pViewportSwizzles) {
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ transform_tohost_VkViewportSwizzleNV(
+ globalstate, (VkViewportSwizzleNV*)(pViewportSwizzles + i));
+ }
+ }
+ vk->vkCmdSetViewportSwizzleNV((VkCommandBuffer)dispatchHandle, firstViewport,
+ viewportCount, pViewportSwizzles);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetCoverageToColorEnableNV: {
+ android::base::beginTrace("vkCmdSetCoverageToColorEnableNV subdecode");
+ VkBool32 coverageToColorEnable;
+ memcpy((VkBool32*)&coverageToColorEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetCoverageToColorEnableNV((VkCommandBuffer)dispatchHandle,
+ coverageToColorEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetCoverageToColorLocationNV: {
+ android::base::beginTrace("vkCmdSetCoverageToColorLocationNV subdecode");
+ uint32_t coverageToColorLocation;
+ memcpy((uint32_t*)&coverageToColorLocation, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ vk->vkCmdSetCoverageToColorLocationNV((VkCommandBuffer)dispatchHandle,
+ coverageToColorLocation);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetCoverageModulationModeNV: {
+ android::base::beginTrace("vkCmdSetCoverageModulationModeNV subdecode");
+ VkCoverageModulationModeNV coverageModulationMode;
+ memcpy((VkCoverageModulationModeNV*)&coverageModulationMode, *readStreamPtrPtr,
+ sizeof(VkCoverageModulationModeNV));
+ *readStreamPtrPtr += sizeof(VkCoverageModulationModeNV);
+ vk->vkCmdSetCoverageModulationModeNV((VkCommandBuffer)dispatchHandle,
+ coverageModulationMode);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetCoverageModulationTableEnableNV: {
+ android::base::beginTrace("vkCmdSetCoverageModulationTableEnableNV subdecode");
+ VkBool32 coverageModulationTableEnable;
+ memcpy((VkBool32*)&coverageModulationTableEnable, *readStreamPtrPtr,
+ sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetCoverageModulationTableEnableNV((VkCommandBuffer)dispatchHandle,
+ coverageModulationTableEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetCoverageModulationTableNV: {
+ android::base::beginTrace("vkCmdSetCoverageModulationTableNV subdecode");
+ uint32_t coverageModulationTableCount;
+ const float* pCoverageModulationTable;
+ float stack_pCoverageModulationTable[MAX_STACK_ITEMS];
+ memcpy((uint32_t*)&coverageModulationTableCount, *readStreamPtrPtr,
+ sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (((coverageModulationTableCount)) <= MAX_STACK_ITEMS) {
+ pCoverageModulationTable = (float*)stack_pCoverageModulationTable;
+ } else {
+ readStream->alloc((void**)&pCoverageModulationTable,
+ ((coverageModulationTableCount)) * sizeof(const float));
+ }
+ memcpy((float*)pCoverageModulationTable, *readStreamPtrPtr,
+ ((coverageModulationTableCount)) * sizeof(const float));
+ *readStreamPtrPtr += ((coverageModulationTableCount)) * sizeof(const float);
+ vk->vkCmdSetCoverageModulationTableNV((VkCommandBuffer)dispatchHandle,
+ coverageModulationTableCount,
+ pCoverageModulationTable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetShadingRateImageEnableNV: {
+ android::base::beginTrace("vkCmdSetShadingRateImageEnableNV subdecode");
+ VkBool32 shadingRateImageEnable;
+ memcpy((VkBool32*)&shadingRateImageEnable, *readStreamPtrPtr, sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetShadingRateImageEnableNV((VkCommandBuffer)dispatchHandle,
+ shadingRateImageEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetRepresentativeFragmentTestEnableNV: {
+ android::base::beginTrace("vkCmdSetRepresentativeFragmentTestEnableNV subdecode");
+ VkBool32 representativeFragmentTestEnable;
+ memcpy((VkBool32*)&representativeFragmentTestEnable, *readStreamPtrPtr,
+ sizeof(VkBool32));
+ *readStreamPtrPtr += sizeof(VkBool32);
+ vk->vkCmdSetRepresentativeFragmentTestEnableNV((VkCommandBuffer)dispatchHandle,
+ representativeFragmentTestEnable);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetCoverageReductionModeNV: {
+ android::base::beginTrace("vkCmdSetCoverageReductionModeNV subdecode");
+ VkCoverageReductionModeNV coverageReductionMode;
+ memcpy((VkCoverageReductionModeNV*)&coverageReductionMode, *readStreamPtrPtr,
+ sizeof(VkCoverageReductionModeNV));
+ *readStreamPtrPtr += sizeof(VkCoverageReductionModeNV);
+ vk->vkCmdSetCoverageReductionModeNV((VkCommandBuffer)dispatchHandle,
+ coverageReductionMode);
+ android::base::endTrace();
+ break;
+ }
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+#endif
+#ifdef VK_EXT_shader_module_identifier
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+ case OP_vkCmdOpticalFlowExecuteNV: {
+ android::base::beginTrace("vkCmdOpticalFlowExecuteNV subdecode");
+ VkOpticalFlowSessionNV session;
+ const VkOpticalFlowExecuteInfoNV* pExecuteInfo;
+ VkOpticalFlowExecuteInfoNV stack_pExecuteInfo[1];
+ memcpy((VkOpticalFlowSessionNV*)&session, (*readStreamPtrPtr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&session);
+ *readStreamPtrPtr += 8;
+ pExecuteInfo = (VkOpticalFlowExecuteInfoNV*)stack_pExecuteInfo;
+ reservedunmarshal_VkOpticalFlowExecuteInfoNV(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkOpticalFlowExecuteInfoNV*)(pExecuteInfo), readStreamPtrPtr);
+ if (pExecuteInfo) {
+ transform_tohost_VkOpticalFlowExecuteInfoNV(
+ globalstate, (VkOpticalFlowExecuteInfoNV*)(pExecuteInfo));
+ }
+ vk->vkCmdOpticalFlowExecuteNV((VkCommandBuffer)dispatchHandle, session,
+ pExecuteInfo);
+ android::base::endTrace();
+ break;
+ }
+#endif
+#ifdef VK_EXT_legacy_dithering
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+#endif
+#ifdef VK_EXT_shader_object
+ case OP_vkCmdBindShadersEXT: {
+ android::base::beginTrace("vkCmdBindShadersEXT subdecode");
+ uint32_t stageCount;
+ const VkShaderStageFlagBits* pStages;
+ VkShaderStageFlagBits stack_pStages[MAX_STACK_ITEMS];
+ const VkShaderEXT* pShaders;
+ VkShaderEXT stack_pShaders[MAX_STACK_ITEMS];
+ memcpy((uint32_t*)&stageCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (((stageCount)) <= MAX_STACK_ITEMS) {
+ pStages = (VkShaderStageFlagBits*)stack_pStages;
+ } else {
+ readStream->alloc((void**)&pStages,
+ ((stageCount)) * sizeof(const VkShaderStageFlagBits));
+ }
+ memcpy((VkShaderStageFlagBits*)pStages, *readStreamPtrPtr,
+ ((stageCount)) * sizeof(const VkShaderStageFlagBits));
+ *readStreamPtrPtr += ((stageCount)) * sizeof(const VkShaderStageFlagBits);
+ // WARNING PTR CHECK
+ memcpy((VkShaderEXT**)&pShaders, (*readStreamPtrPtr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&pShaders);
+ *readStreamPtrPtr += 8;
+ if (pShaders) {
+ if (((stageCount)) <= MAX_STACK_ITEMS) {
+ pShaders = (VkShaderEXT*)stack_pShaders;
+ } else {
+ readStream->alloc((void**)&pShaders,
+ ((stageCount)) * sizeof(const VkShaderEXT));
+ }
+ for (uint32_t i = 0; i < (uint32_t)((stageCount)); ++i) {
+ memcpy((VkShaderEXT*)&pShaders[i], (*readStreamPtrPtr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&pShaders[i]);
+ *readStreamPtrPtr += 8;
+ }
+ }
+ vk->vkCmdBindShadersEXT((VkCommandBuffer)dispatchHandle, stageCount, pStages,
+ pShaders);
+ android::base::endTrace();
+ break;
+ }
+#endif
+#ifdef VK_QCOM_tile_properties
+#endif
+#ifdef VK_SEC_amigo_profiling
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+ case OP_vkCmdSetAttachmentFeedbackLoopEnableEXT: {
+ android::base::beginTrace("vkCmdSetAttachmentFeedbackLoopEnableEXT subdecode");
+ VkImageAspectFlags aspectMask;
+ memcpy((VkImageAspectFlags*)&aspectMask, *readStreamPtrPtr,
+ sizeof(VkImageAspectFlags));
+ *readStreamPtrPtr += sizeof(VkImageAspectFlags);
+ vk->vkCmdSetAttachmentFeedbackLoopEnableEXT((VkCommandBuffer)dispatchHandle,
+ aspectMask);
+ android::base::endTrace();
+ break;
+ }
+#endif
#ifdef VK_KHR_acceleration_structure
case OP_vkCmdBuildAccelerationStructuresKHR: {
android::base::beginTrace("vkCmdBuildAccelerationStructuresKHR subdecode");
@@ -4588,6 +6124,75 @@
#endif
#ifdef VK_KHR_ray_query
#endif
+#ifdef VK_EXT_mesh_shader
+ case OP_vkCmdDrawMeshTasksEXT: {
+ android::base::beginTrace("vkCmdDrawMeshTasksEXT subdecode");
+ uint32_t groupCountX;
+ uint32_t groupCountY;
+ uint32_t groupCountZ;
+ memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ vk->vkCmdDrawMeshTasksEXT((VkCommandBuffer)dispatchHandle, groupCountX, groupCountY,
+ groupCountZ);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdDrawMeshTasksIndirectEXT: {
+ android::base::beginTrace("vkCmdDrawMeshTasksIndirectEXT subdecode");
+ VkBuffer buffer;
+ VkDeviceSize offset;
+ uint32_t drawCount;
+ uint32_t stride;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+ memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+ *readStreamPtrPtr += sizeof(VkDeviceSize);
+ memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ vk->vkCmdDrawMeshTasksIndirectEXT((VkCommandBuffer)dispatchHandle, buffer, offset,
+ drawCount, stride);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdDrawMeshTasksIndirectCountEXT: {
+ android::base::beginTrace("vkCmdDrawMeshTasksIndirectCountEXT subdecode");
+ VkBuffer buffer;
+ VkDeviceSize offset;
+ VkBuffer countBuffer;
+ VkDeviceSize countBufferOffset;
+ uint32_t maxDrawCount;
+ uint32_t stride;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+ memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+ *readStreamPtrPtr += sizeof(VkDeviceSize);
+ uint64_t cgen_var_1;
+ memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
+ memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+ *readStreamPtrPtr += sizeof(VkDeviceSize);
+ memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ vk->vkCmdDrawMeshTasksIndirectCountEXT((VkCommandBuffer)dispatchHandle, buffer,
+ offset, countBuffer, countBufferOffset,
+ maxDrawCount, stride);
+ android::base::endTrace();
+ break;
+ }
+#endif
default: {
GFXSTREAM_ABORT(::emugl::FatalError(::emugl::ABORT_REASON_OTHER))
<< "Unrecognized opcode " << opcode;
