1 // Copyright (C) 2018 The Android Open Source Project
2 // Copyright (C) 2018 Google Inc.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15
16 // Autogenerated module VkSubDecoder
17 // (impl) generated by protocols/vulkan/xml/genvk.py -registry protocols/vulkan/xml/vk.xml cereal -o stream-servers/vulkan/cereal
18 // Please do not modify directly;
19 // re-run generate-vulkan-sources.sh,
20 // or directly from Python by defining:
21 // VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
22 // CEREAL_OUTPUT_DIR: Where to put the generated sources.
23 // python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
24 #define MAX_STACK_ITEMS 16
subDecode(VulkanMemReadingStream * readStream,VulkanDispatch * vk,void * boxed_dispatchHandle,void * dispatchHandle,VkDeviceSize dataSize,const void * pData)25 size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* boxed_dispatchHandle, void* dispatchHandle, VkDeviceSize dataSize, const void* pData)
26 {
27 uint32_t count = 0;
28 unsigned char *buf = (unsigned char *)pData;
29 android::base::BumpPool* pool = readStream->pool();
30 unsigned char *ptr = (unsigned char *)pData;
31 const unsigned char* const end = (const unsigned char*)buf + dataSize;
32 VkDecoderGlobalState* globalstate = VkDecoderGlobalState::get();
33 while (end - ptr >= 8)
34 {
35 uint32_t opcode = *(uint32_t *)ptr;
36 int32_t packetLen = *(int32_t *)(ptr + 4);
37 if (end - ptr < packetLen) return ptr - (unsigned char*)buf;
38 readStream->setBuf((uint8_t*)(ptr + 8));
39 uint8_t* readStreamPtr = readStream->getBuf(); uint8_t** readStreamPtrPtr = &readStreamPtr;
40 switch (opcode)
41 {
42 #ifdef VK_VERSION_1_0
43 case OP_vkBeginCommandBuffer:
44 {
45 android::base::beginTrace("vkBeginCommandBuffer subdecode");
46 const VkCommandBufferBeginInfo* pBeginInfo;
47 VkCommandBufferBeginInfo stack_pBeginInfo[1];
48 pBeginInfo = (VkCommandBufferBeginInfo*)stack_pBeginInfo;
49 reservedunmarshal_VkCommandBufferBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCommandBufferBeginInfo*)(pBeginInfo), readStreamPtrPtr);
50 if (pBeginInfo)
51 {
52 transform_tohost_VkCommandBufferBeginInfo(globalstate, (VkCommandBufferBeginInfo*)(pBeginInfo));
53 }
54 VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
55 vkBeginCommandBuffer_VkResult_return = this->on_vkBeginCommandBuffer(pool, (VkCommandBuffer)(boxed_dispatchHandle), pBeginInfo);
56 android::base::endTrace();
57 break;
58 }
59 case OP_vkEndCommandBuffer:
60 {
61 android::base::beginTrace("vkEndCommandBuffer subdecode");
62 VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
63 vkEndCommandBuffer_VkResult_return = vk->vkEndCommandBuffer((VkCommandBuffer)dispatchHandle);
64 android::base::endTrace();
65 break;
66 }
67 case OP_vkResetCommandBuffer:
68 {
69 android::base::beginTrace("vkResetCommandBuffer subdecode");
70 VkCommandBufferResetFlags flags;
71 memcpy((VkCommandBufferResetFlags*)&flags, *readStreamPtrPtr, sizeof(VkCommandBufferResetFlags));
72 *readStreamPtrPtr += sizeof(VkCommandBufferResetFlags);
73 VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
74 vkResetCommandBuffer_VkResult_return = this->on_vkResetCommandBuffer(pool, (VkCommandBuffer)(boxed_dispatchHandle), flags);
75 android::base::endTrace();
76 break;
77 }
78 case OP_vkCmdBindPipeline:
79 {
80 android::base::beginTrace("vkCmdBindPipeline subdecode");
81 VkPipelineBindPoint pipelineBindPoint;
82 VkPipeline pipeline;
83 memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr, sizeof(VkPipelineBindPoint));
84 *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
85 uint64_t cgen_var_0;
86 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
87 *readStreamPtrPtr += 1 * 8;
88 *(VkPipeline*)&pipeline = (VkPipeline)unbox_VkPipeline((VkPipeline)(*&cgen_var_0));
89 this->on_vkCmdBindPipeline(pool, (VkCommandBuffer)(boxed_dispatchHandle), pipelineBindPoint, pipeline);
90 android::base::endTrace();
91 break;
92 }
93 case OP_vkCmdSetViewport:
94 {
95 android::base::beginTrace("vkCmdSetViewport subdecode");
96 uint32_t firstViewport;
97 uint32_t viewportCount;
98 const VkViewport* pViewports;
99 VkViewport stack_pViewports[MAX_STACK_ITEMS];
100 memcpy((uint32_t*)&firstViewport, *readStreamPtrPtr, sizeof(uint32_t));
101 *readStreamPtrPtr += sizeof(uint32_t);
102 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
103 *readStreamPtrPtr += sizeof(uint32_t);
104 if (((viewportCount)) <= MAX_STACK_ITEMS)
105 {
106 pViewports = (VkViewport*)stack_pViewports;
107 }
108 else
109 {
110 readStream->alloc((void**)&pViewports, ((viewportCount)) * sizeof(const VkViewport));
111 }
112 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
113 {
114 reservedunmarshal_VkViewport(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViewport*)(pViewports + i), readStreamPtrPtr);
115 }
116 if (pViewports)
117 {
118 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
119 {
120 transform_tohost_VkViewport(globalstate, (VkViewport*)(pViewports + i));
121 }
122 }
123 vk->vkCmdSetViewport((VkCommandBuffer)dispatchHandle, firstViewport, viewportCount, pViewports);
124 android::base::endTrace();
125 break;
126 }
127 case OP_vkCmdSetScissor:
128 {
129 android::base::beginTrace("vkCmdSetScissor subdecode");
130 uint32_t firstScissor;
131 uint32_t scissorCount;
132 const VkRect2D* pScissors;
133 VkRect2D stack_pScissors[MAX_STACK_ITEMS];
134 memcpy((uint32_t*)&firstScissor, *readStreamPtrPtr, sizeof(uint32_t));
135 *readStreamPtrPtr += sizeof(uint32_t);
136 memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
137 *readStreamPtrPtr += sizeof(uint32_t);
138 if (((scissorCount)) <= MAX_STACK_ITEMS)
139 {
140 pScissors = (VkRect2D*)stack_pScissors;
141 }
142 else
143 {
144 readStream->alloc((void**)&pScissors, ((scissorCount)) * sizeof(const VkRect2D));
145 }
146 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
147 {
148 reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(pScissors + i), readStreamPtrPtr);
149 }
150 if (pScissors)
151 {
152 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
153 {
154 transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pScissors + i));
155 }
156 }
157 vk->vkCmdSetScissor((VkCommandBuffer)dispatchHandle, firstScissor, scissorCount, pScissors);
158 android::base::endTrace();
159 break;
160 }
161 case OP_vkCmdSetLineWidth:
162 {
163 android::base::beginTrace("vkCmdSetLineWidth subdecode");
164 float lineWidth;
165 memcpy((float*)&lineWidth, *readStreamPtrPtr, sizeof(float));
166 *readStreamPtrPtr += sizeof(float);
167 vk->vkCmdSetLineWidth((VkCommandBuffer)dispatchHandle, lineWidth);
168 android::base::endTrace();
169 break;
170 }
171 case OP_vkCmdSetDepthBias:
172 {
173 android::base::beginTrace("vkCmdSetDepthBias subdecode");
174 float depthBiasConstantFactor;
175 float depthBiasClamp;
176 float depthBiasSlopeFactor;
177 memcpy((float*)&depthBiasConstantFactor, *readStreamPtrPtr, sizeof(float));
178 *readStreamPtrPtr += sizeof(float);
179 memcpy((float*)&depthBiasClamp, *readStreamPtrPtr, sizeof(float));
180 *readStreamPtrPtr += sizeof(float);
181 memcpy((float*)&depthBiasSlopeFactor, *readStreamPtrPtr, sizeof(float));
182 *readStreamPtrPtr += sizeof(float);
183 vk->vkCmdSetDepthBias((VkCommandBuffer)dispatchHandle, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
184 android::base::endTrace();
185 break;
186 }
187 case OP_vkCmdSetBlendConstants:
188 {
189 android::base::beginTrace("vkCmdSetBlendConstants subdecode");
190 float blendConstants[4];
191 memcpy((float*)blendConstants, *readStreamPtrPtr, 4 * sizeof(const float));
192 *readStreamPtrPtr += 4 * sizeof(const float);
193 vk->vkCmdSetBlendConstants((VkCommandBuffer)dispatchHandle, blendConstants);
194 android::base::endTrace();
195 break;
196 }
197 case OP_vkCmdSetDepthBounds:
198 {
199 android::base::beginTrace("vkCmdSetDepthBounds subdecode");
200 float minDepthBounds;
201 float maxDepthBounds;
202 memcpy((float*)&minDepthBounds, *readStreamPtrPtr, sizeof(float));
203 *readStreamPtrPtr += sizeof(float);
204 memcpy((float*)&maxDepthBounds, *readStreamPtrPtr, sizeof(float));
205 *readStreamPtrPtr += sizeof(float);
206 vk->vkCmdSetDepthBounds((VkCommandBuffer)dispatchHandle, minDepthBounds, maxDepthBounds);
207 android::base::endTrace();
208 break;
209 }
210 case OP_vkCmdSetStencilCompareMask:
211 {
212 android::base::beginTrace("vkCmdSetStencilCompareMask subdecode");
213 VkStencilFaceFlags faceMask;
214 uint32_t compareMask;
215 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr, sizeof(VkStencilFaceFlags));
216 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
217 memcpy((uint32_t*)&compareMask, *readStreamPtrPtr, sizeof(uint32_t));
218 *readStreamPtrPtr += sizeof(uint32_t);
219 vk->vkCmdSetStencilCompareMask((VkCommandBuffer)dispatchHandle, faceMask, compareMask);
220 android::base::endTrace();
221 break;
222 }
223 case OP_vkCmdSetStencilWriteMask:
224 {
225 android::base::beginTrace("vkCmdSetStencilWriteMask subdecode");
226 VkStencilFaceFlags faceMask;
227 uint32_t writeMask;
228 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr, sizeof(VkStencilFaceFlags));
229 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
230 memcpy((uint32_t*)&writeMask, *readStreamPtrPtr, sizeof(uint32_t));
231 *readStreamPtrPtr += sizeof(uint32_t);
232 vk->vkCmdSetStencilWriteMask((VkCommandBuffer)dispatchHandle, faceMask, writeMask);
233 android::base::endTrace();
234 break;
235 }
236 case OP_vkCmdSetStencilReference:
237 {
238 android::base::beginTrace("vkCmdSetStencilReference subdecode");
239 VkStencilFaceFlags faceMask;
240 uint32_t reference;
241 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr, sizeof(VkStencilFaceFlags));
242 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
243 memcpy((uint32_t*)&reference, *readStreamPtrPtr, sizeof(uint32_t));
244 *readStreamPtrPtr += sizeof(uint32_t);
245 vk->vkCmdSetStencilReference((VkCommandBuffer)dispatchHandle, faceMask, reference);
246 android::base::endTrace();
247 break;
248 }
249 case OP_vkCmdBindDescriptorSets:
250 {
251 android::base::beginTrace("vkCmdBindDescriptorSets subdecode");
252 VkPipelineBindPoint pipelineBindPoint;
253 VkPipelineLayout layout;
254 uint32_t firstSet;
255 uint32_t descriptorSetCount;
256 const VkDescriptorSet* pDescriptorSets;
257 VkDescriptorSet stack_pDescriptorSets[MAX_STACK_ITEMS];
258 uint32_t dynamicOffsetCount;
259 const uint32_t* pDynamicOffsets;
260 uint32_t stack_pDynamicOffsets[MAX_STACK_ITEMS];
261 memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr, sizeof(VkPipelineBindPoint));
262 *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
263 uint64_t cgen_var_0;
264 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
265 *readStreamPtrPtr += 1 * 8;
266 *(VkPipelineLayout*)&layout = (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
267 memcpy((uint32_t*)&firstSet, *readStreamPtrPtr, sizeof(uint32_t));
268 *readStreamPtrPtr += sizeof(uint32_t);
269 memcpy((uint32_t*)&descriptorSetCount, *readStreamPtrPtr, sizeof(uint32_t));
270 *readStreamPtrPtr += sizeof(uint32_t);
271 if (((descriptorSetCount)) <= MAX_STACK_ITEMS)
272 {
273 pDescriptorSets = (VkDescriptorSet*)stack_pDescriptorSets;
274 }
275 else
276 {
277 readStream->alloc((void**)&pDescriptorSets, ((descriptorSetCount)) * sizeof(const VkDescriptorSet));
278 }
279 if (((descriptorSetCount)))
280 {
281 uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
282 *readStreamPtrPtr += 8 * ((descriptorSetCount));
283 for (uint32_t k = 0; k < ((descriptorSetCount)); ++k)
284 {
285 uint64_t tmpval; memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
286 *(((VkDescriptorSet*)pDescriptorSets) + k) = (VkDescriptorSet)unbox_VkDescriptorSet((VkDescriptorSet)tmpval);
287 }
288 }
289 memcpy((uint32_t*)&dynamicOffsetCount, *readStreamPtrPtr, sizeof(uint32_t));
290 *readStreamPtrPtr += sizeof(uint32_t);
291 if (((dynamicOffsetCount)) <= MAX_STACK_ITEMS)
292 {
293 pDynamicOffsets = (uint32_t*)stack_pDynamicOffsets;
294 }
295 else
296 {
297 readStream->alloc((void**)&pDynamicOffsets, ((dynamicOffsetCount)) * sizeof(const uint32_t));
298 }
299 memcpy((uint32_t*)pDynamicOffsets, *readStreamPtrPtr, ((dynamicOffsetCount)) * sizeof(const uint32_t));
300 *readStreamPtrPtr += ((dynamicOffsetCount)) * sizeof(const uint32_t);
301 this->on_vkCmdBindDescriptorSets(pool, (VkCommandBuffer)(boxed_dispatchHandle), pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
302 android::base::endTrace();
303 break;
304 }
305 case OP_vkCmdBindIndexBuffer:
306 {
307 android::base::beginTrace("vkCmdBindIndexBuffer subdecode");
308 VkBuffer buffer;
309 VkDeviceSize offset;
310 VkIndexType indexType;
311 uint64_t cgen_var_0;
312 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
313 *readStreamPtrPtr += 1 * 8;
314 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
315 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
316 *readStreamPtrPtr += sizeof(VkDeviceSize);
317 memcpy((VkIndexType*)&indexType, *readStreamPtrPtr, sizeof(VkIndexType));
318 *readStreamPtrPtr += sizeof(VkIndexType);
319 vk->vkCmdBindIndexBuffer((VkCommandBuffer)dispatchHandle, buffer, offset, indexType);
320 android::base::endTrace();
321 break;
322 }
323 case OP_vkCmdBindVertexBuffers:
324 {
325 android::base::beginTrace("vkCmdBindVertexBuffers subdecode");
326 uint32_t firstBinding;
327 uint32_t bindingCount;
328 const VkBuffer* pBuffers;
329 VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
330 const VkDeviceSize* pOffsets;
331 VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
332 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
333 *readStreamPtrPtr += sizeof(uint32_t);
334 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
335 *readStreamPtrPtr += sizeof(uint32_t);
336 if (((bindingCount)) <= MAX_STACK_ITEMS)
337 {
338 pBuffers = (VkBuffer*)stack_pBuffers;
339 }
340 else
341 {
342 readStream->alloc((void**)&pBuffers, ((bindingCount)) * sizeof(const VkBuffer));
343 }
344 if (((bindingCount)))
345 {
346 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
347 *readStreamPtrPtr += 8 * ((bindingCount));
348 for (uint32_t k = 0; k < ((bindingCount)); ++k)
349 {
350 uint64_t tmpval; memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
351 *(((VkBuffer*)pBuffers) + k) = (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval);
352 }
353 }
354 if (((bindingCount)) <= MAX_STACK_ITEMS)
355 {
356 pOffsets = (VkDeviceSize*)stack_pOffsets;
357 }
358 else
359 {
360 readStream->alloc((void**)&pOffsets, ((bindingCount)) * sizeof(const VkDeviceSize));
361 }
362 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr, ((bindingCount)) * sizeof(const VkDeviceSize));
363 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
364 vk->vkCmdBindVertexBuffers((VkCommandBuffer)dispatchHandle, firstBinding, bindingCount, pBuffers, pOffsets);
365 android::base::endTrace();
366 break;
367 }
368 case OP_vkCmdDraw:
369 {
370 android::base::beginTrace("vkCmdDraw subdecode");
371 uint32_t vertexCount;
372 uint32_t instanceCount;
373 uint32_t firstVertex;
374 uint32_t firstInstance;
375 memcpy((uint32_t*)&vertexCount, *readStreamPtrPtr, sizeof(uint32_t));
376 *readStreamPtrPtr += sizeof(uint32_t);
377 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
378 *readStreamPtrPtr += sizeof(uint32_t);
379 memcpy((uint32_t*)&firstVertex, *readStreamPtrPtr, sizeof(uint32_t));
380 *readStreamPtrPtr += sizeof(uint32_t);
381 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
382 *readStreamPtrPtr += sizeof(uint32_t);
383 vk->vkCmdDraw((VkCommandBuffer)dispatchHandle, vertexCount, instanceCount, firstVertex, firstInstance);
384 android::base::endTrace();
385 break;
386 }
387 case OP_vkCmdDrawIndexed:
388 {
389 android::base::beginTrace("vkCmdDrawIndexed subdecode");
390 uint32_t indexCount;
391 uint32_t instanceCount;
392 uint32_t firstIndex;
393 int32_t vertexOffset;
394 uint32_t firstInstance;
395 memcpy((uint32_t*)&indexCount, *readStreamPtrPtr, sizeof(uint32_t));
396 *readStreamPtrPtr += sizeof(uint32_t);
397 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
398 *readStreamPtrPtr += sizeof(uint32_t);
399 memcpy((uint32_t*)&firstIndex, *readStreamPtrPtr, sizeof(uint32_t));
400 *readStreamPtrPtr += sizeof(uint32_t);
401 memcpy((int32_t*)&vertexOffset, *readStreamPtrPtr, sizeof(int32_t));
402 *readStreamPtrPtr += sizeof(int32_t);
403 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
404 *readStreamPtrPtr += sizeof(uint32_t);
405 vk->vkCmdDrawIndexed((VkCommandBuffer)dispatchHandle, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
406 android::base::endTrace();
407 break;
408 }
409 case OP_vkCmdDrawIndirect:
410 {
411 android::base::beginTrace("vkCmdDrawIndirect subdecode");
412 VkBuffer buffer;
413 VkDeviceSize offset;
414 uint32_t drawCount;
415 uint32_t stride;
416 uint64_t cgen_var_0;
417 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
418 *readStreamPtrPtr += 1 * 8;
419 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
420 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
421 *readStreamPtrPtr += sizeof(VkDeviceSize);
422 memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
423 *readStreamPtrPtr += sizeof(uint32_t);
424 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
425 *readStreamPtrPtr += sizeof(uint32_t);
426 vk->vkCmdDrawIndirect((VkCommandBuffer)dispatchHandle, buffer, offset, drawCount, stride);
427 android::base::endTrace();
428 break;
429 }
430 case OP_vkCmdDrawIndexedIndirect:
431 {
432 android::base::beginTrace("vkCmdDrawIndexedIndirect subdecode");
433 VkBuffer buffer;
434 VkDeviceSize offset;
435 uint32_t drawCount;
436 uint32_t stride;
437 uint64_t cgen_var_0;
438 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
439 *readStreamPtrPtr += 1 * 8;
440 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
441 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
442 *readStreamPtrPtr += sizeof(VkDeviceSize);
443 memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
444 *readStreamPtrPtr += sizeof(uint32_t);
445 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
446 *readStreamPtrPtr += sizeof(uint32_t);
447 vk->vkCmdDrawIndexedIndirect((VkCommandBuffer)dispatchHandle, buffer, offset, drawCount, stride);
448 android::base::endTrace();
449 break;
450 }
451 case OP_vkCmdDispatch:
452 {
453 android::base::beginTrace("vkCmdDispatch subdecode");
454 uint32_t groupCountX;
455 uint32_t groupCountY;
456 uint32_t groupCountZ;
457 memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
458 *readStreamPtrPtr += sizeof(uint32_t);
459 memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
460 *readStreamPtrPtr += sizeof(uint32_t);
461 memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
462 *readStreamPtrPtr += sizeof(uint32_t);
463 vk->vkCmdDispatch((VkCommandBuffer)dispatchHandle, groupCountX, groupCountY, groupCountZ);
464 android::base::endTrace();
465 break;
466 }
467 case OP_vkCmdDispatchIndirect:
468 {
469 android::base::beginTrace("vkCmdDispatchIndirect subdecode");
470 VkBuffer buffer;
471 VkDeviceSize offset;
472 uint64_t cgen_var_0;
473 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
474 *readStreamPtrPtr += 1 * 8;
475 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
476 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
477 *readStreamPtrPtr += sizeof(VkDeviceSize);
478 vk->vkCmdDispatchIndirect((VkCommandBuffer)dispatchHandle, buffer, offset);
479 android::base::endTrace();
480 break;
481 }
482 case OP_vkCmdCopyBuffer:
483 {
484 android::base::beginTrace("vkCmdCopyBuffer subdecode");
485 VkBuffer srcBuffer;
486 VkBuffer dstBuffer;
487 uint32_t regionCount;
488 const VkBufferCopy* pRegions;
489 VkBufferCopy stack_pRegions[MAX_STACK_ITEMS];
490 uint64_t cgen_var_0;
491 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
492 *readStreamPtrPtr += 1 * 8;
493 *(VkBuffer*)&srcBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
494 uint64_t cgen_var_1;
495 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
496 *readStreamPtrPtr += 1 * 8;
497 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
498 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
499 *readStreamPtrPtr += sizeof(uint32_t);
500 if (((regionCount)) <= MAX_STACK_ITEMS)
501 {
502 pRegions = (VkBufferCopy*)stack_pRegions;
503 }
504 else
505 {
506 readStream->alloc((void**)&pRegions, ((regionCount)) * sizeof(const VkBufferCopy));
507 }
508 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
509 {
510 reservedunmarshal_VkBufferCopy(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferCopy*)(pRegions + i), readStreamPtrPtr);
511 }
512 if (pRegions)
513 {
514 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
515 {
516 transform_tohost_VkBufferCopy(globalstate, (VkBufferCopy*)(pRegions + i));
517 }
518 }
519 vk->vkCmdCopyBuffer((VkCommandBuffer)dispatchHandle, srcBuffer, dstBuffer, regionCount, pRegions);
520 android::base::endTrace();
521 break;
522 }
523 case OP_vkCmdCopyImage:
524 {
525 android::base::beginTrace("vkCmdCopyImage subdecode");
526 VkImage srcImage;
527 VkImageLayout srcImageLayout;
528 VkImage dstImage;
529 VkImageLayout dstImageLayout;
530 uint32_t regionCount;
531 const VkImageCopy* pRegions;
532 VkImageCopy stack_pRegions[MAX_STACK_ITEMS];
533 uint64_t cgen_var_0;
534 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
535 *readStreamPtrPtr += 1 * 8;
536 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
537 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
538 *readStreamPtrPtr += sizeof(VkImageLayout);
539 uint64_t cgen_var_1;
540 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
541 *readStreamPtrPtr += 1 * 8;
542 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
543 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
544 *readStreamPtrPtr += sizeof(VkImageLayout);
545 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
546 *readStreamPtrPtr += sizeof(uint32_t);
547 if (((regionCount)) <= MAX_STACK_ITEMS)
548 {
549 pRegions = (VkImageCopy*)stack_pRegions;
550 }
551 else
552 {
553 readStream->alloc((void**)&pRegions, ((regionCount)) * sizeof(const VkImageCopy));
554 }
555 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
556 {
557 reservedunmarshal_VkImageCopy(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageCopy*)(pRegions + i), readStreamPtrPtr);
558 }
559 if (pRegions)
560 {
561 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
562 {
563 transform_tohost_VkImageCopy(globalstate, (VkImageCopy*)(pRegions + i));
564 }
565 }
566 this->on_vkCmdCopyImage(pool, (VkCommandBuffer)(boxed_dispatchHandle), srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
567 android::base::endTrace();
568 break;
569 }
570 case OP_vkCmdBlitImage:
571 {
572 android::base::beginTrace("vkCmdBlitImage subdecode");
573 VkImage srcImage;
574 VkImageLayout srcImageLayout;
575 VkImage dstImage;
576 VkImageLayout dstImageLayout;
577 uint32_t regionCount;
578 const VkImageBlit* pRegions;
579 VkImageBlit stack_pRegions[MAX_STACK_ITEMS];
580 VkFilter filter;
581 uint64_t cgen_var_0;
582 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
583 *readStreamPtrPtr += 1 * 8;
584 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
585 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
586 *readStreamPtrPtr += sizeof(VkImageLayout);
587 uint64_t cgen_var_1;
588 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
589 *readStreamPtrPtr += 1 * 8;
590 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
591 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
592 *readStreamPtrPtr += sizeof(VkImageLayout);
593 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
594 *readStreamPtrPtr += sizeof(uint32_t);
595 if (((regionCount)) <= MAX_STACK_ITEMS)
596 {
597 pRegions = (VkImageBlit*)stack_pRegions;
598 }
599 else
600 {
601 readStream->alloc((void**)&pRegions, ((regionCount)) * sizeof(const VkImageBlit));
602 }
603 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
604 {
605 reservedunmarshal_VkImageBlit(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageBlit*)(pRegions + i), readStreamPtrPtr);
606 }
607 memcpy((VkFilter*)&filter, *readStreamPtrPtr, sizeof(VkFilter));
608 *readStreamPtrPtr += sizeof(VkFilter);
609 if (pRegions)
610 {
611 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
612 {
613 transform_tohost_VkImageBlit(globalstate, (VkImageBlit*)(pRegions + i));
614 }
615 }
616 vk->vkCmdBlitImage((VkCommandBuffer)dispatchHandle, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
617 android::base::endTrace();
618 break;
619 }
620 case OP_vkCmdCopyBufferToImage:
621 {
622 android::base::beginTrace("vkCmdCopyBufferToImage subdecode");
623 VkBuffer srcBuffer;
624 VkImage dstImage;
625 VkImageLayout dstImageLayout;
626 uint32_t regionCount;
627 const VkBufferImageCopy* pRegions;
628 VkBufferImageCopy stack_pRegions[MAX_STACK_ITEMS];
629 uint64_t cgen_var_0;
630 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
631 *readStreamPtrPtr += 1 * 8;
632 *(VkBuffer*)&srcBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
633 uint64_t cgen_var_1;
634 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
635 *readStreamPtrPtr += 1 * 8;
636 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
637 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
638 *readStreamPtrPtr += sizeof(VkImageLayout);
639 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
640 *readStreamPtrPtr += sizeof(uint32_t);
641 if (((regionCount)) <= MAX_STACK_ITEMS)
642 {
643 pRegions = (VkBufferImageCopy*)stack_pRegions;
644 }
645 else
646 {
647 readStream->alloc((void**)&pRegions, ((regionCount)) * sizeof(const VkBufferImageCopy));
648 }
649 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
650 {
651 reservedunmarshal_VkBufferImageCopy(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferImageCopy*)(pRegions + i), readStreamPtrPtr);
652 }
653 if (pRegions)
654 {
655 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
656 {
657 transform_tohost_VkBufferImageCopy(globalstate, (VkBufferImageCopy*)(pRegions + i));
658 }
659 }
660 this->on_vkCmdCopyBufferToImage(pool, (VkCommandBuffer)(boxed_dispatchHandle), srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
661 android::base::endTrace();
662 break;
663 }
664 case OP_vkCmdCopyImageToBuffer:
665 {
666 android::base::beginTrace("vkCmdCopyImageToBuffer subdecode");
667 VkImage srcImage;
668 VkImageLayout srcImageLayout;
669 VkBuffer dstBuffer;
670 uint32_t regionCount;
671 const VkBufferImageCopy* pRegions;
672 VkBufferImageCopy stack_pRegions[MAX_STACK_ITEMS];
673 uint64_t cgen_var_0;
674 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
675 *readStreamPtrPtr += 1 * 8;
676 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
677 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
678 *readStreamPtrPtr += sizeof(VkImageLayout);
679 uint64_t cgen_var_1;
680 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
681 *readStreamPtrPtr += 1 * 8;
682 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
683 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
684 *readStreamPtrPtr += sizeof(uint32_t);
685 if (((regionCount)) <= MAX_STACK_ITEMS)
686 {
687 pRegions = (VkBufferImageCopy*)stack_pRegions;
688 }
689 else
690 {
691 readStream->alloc((void**)&pRegions, ((regionCount)) * sizeof(const VkBufferImageCopy));
692 }
693 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
694 {
695 reservedunmarshal_VkBufferImageCopy(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferImageCopy*)(pRegions + i), readStreamPtrPtr);
696 }
697 if (pRegions)
698 {
699 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
700 {
701 transform_tohost_VkBufferImageCopy(globalstate, (VkBufferImageCopy*)(pRegions + i));
702 }
703 }
704 this->on_vkCmdCopyImageToBuffer(pool, (VkCommandBuffer)(boxed_dispatchHandle), srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
705 android::base::endTrace();
706 break;
707 }
708 case OP_vkCmdUpdateBuffer:
709 {
710 android::base::beginTrace("vkCmdUpdateBuffer subdecode");
711 VkBuffer dstBuffer;
712 VkDeviceSize dstOffset;
713 VkDeviceSize dataSize;
714 const void* pData;
715 uint8_t* stack_pData[MAX_STACK_ITEMS];
716 uint64_t cgen_var_0;
717 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
718 *readStreamPtrPtr += 1 * 8;
719 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
720 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
721 *readStreamPtrPtr += sizeof(VkDeviceSize);
722 memcpy((VkDeviceSize*)&dataSize, *readStreamPtrPtr, sizeof(VkDeviceSize));
723 *readStreamPtrPtr += sizeof(VkDeviceSize);
724 if (((dataSize)) <= MAX_STACK_ITEMS)
725 {
726 pData = (void*)stack_pData;
727 }
728 else
729 {
730 readStream->alloc((void**)&pData, ((dataSize)) * sizeof(const uint8_t));
731 }
732 memcpy((void*)pData, *readStreamPtrPtr, ((dataSize)) * sizeof(const uint8_t));
733 *readStreamPtrPtr += ((dataSize)) * sizeof(const uint8_t);
734 vk->vkCmdUpdateBuffer((VkCommandBuffer)dispatchHandle, dstBuffer, dstOffset, dataSize, pData);
735 android::base::endTrace();
736 break;
737 }
738 case OP_vkCmdFillBuffer:
739 {
740 android::base::beginTrace("vkCmdFillBuffer subdecode");
741 VkBuffer dstBuffer;
742 VkDeviceSize dstOffset;
743 VkDeviceSize size;
744 uint32_t data;
745 uint64_t cgen_var_0;
746 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
747 *readStreamPtrPtr += 1 * 8;
748 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
749 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
750 *readStreamPtrPtr += sizeof(VkDeviceSize);
751 memcpy((VkDeviceSize*)&size, *readStreamPtrPtr, sizeof(VkDeviceSize));
752 *readStreamPtrPtr += sizeof(VkDeviceSize);
753 memcpy((uint32_t*)&data, *readStreamPtrPtr, sizeof(uint32_t));
754 *readStreamPtrPtr += sizeof(uint32_t);
755 vk->vkCmdFillBuffer((VkCommandBuffer)dispatchHandle, dstBuffer, dstOffset, size, data);
756 android::base::endTrace();
757 break;
758 }
759 case OP_vkCmdClearColorImage:
760 {
761 android::base::beginTrace("vkCmdClearColorImage subdecode");
762 VkImage image;
763 VkImageLayout imageLayout;
764 const VkClearColorValue* pColor;
765 VkClearColorValue stack_pColor[1];
766 uint32_t rangeCount;
767 const VkImageSubresourceRange* pRanges;
768 VkImageSubresourceRange stack_pRanges[MAX_STACK_ITEMS];
769 uint64_t cgen_var_0;
770 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
771 *readStreamPtrPtr += 1 * 8;
772 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
773 memcpy((VkImageLayout*)&imageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
774 *readStreamPtrPtr += sizeof(VkImageLayout);
775 pColor = (VkClearColorValue*)stack_pColor;
776 reservedunmarshal_VkClearColorValue(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkClearColorValue*)(pColor), readStreamPtrPtr);
777 memcpy((uint32_t*)&rangeCount, *readStreamPtrPtr, sizeof(uint32_t));
778 *readStreamPtrPtr += sizeof(uint32_t);
779 if (((rangeCount)) <= MAX_STACK_ITEMS)
780 {
781 pRanges = (VkImageSubresourceRange*)stack_pRanges;
782 }
783 else
784 {
785 readStream->alloc((void**)&pRanges, ((rangeCount)) * sizeof(const VkImageSubresourceRange));
786 }
787 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
788 {
789 reservedunmarshal_VkImageSubresourceRange(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSubresourceRange*)(pRanges + i), readStreamPtrPtr);
790 }
791 if (pColor)
792 {
793 transform_tohost_VkClearColorValue(globalstate, (VkClearColorValue*)(pColor));
794 }
795 if (pRanges)
796 {
797 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
798 {
799 transform_tohost_VkImageSubresourceRange(globalstate, (VkImageSubresourceRange*)(pRanges + i));
800 }
801 }
802 vk->vkCmdClearColorImage((VkCommandBuffer)dispatchHandle, image, imageLayout, pColor, rangeCount, pRanges);
803 android::base::endTrace();
804 break;
805 }
806 case OP_vkCmdClearDepthStencilImage:
807 {
808 android::base::beginTrace("vkCmdClearDepthStencilImage subdecode");
809 VkImage image;
810 VkImageLayout imageLayout;
811 const VkClearDepthStencilValue* pDepthStencil;
812 VkClearDepthStencilValue stack_pDepthStencil[1];
813 uint32_t rangeCount;
814 const VkImageSubresourceRange* pRanges;
815 VkImageSubresourceRange stack_pRanges[MAX_STACK_ITEMS];
816 uint64_t cgen_var_0;
817 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
818 *readStreamPtrPtr += 1 * 8;
819 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
820 memcpy((VkImageLayout*)&imageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
821 *readStreamPtrPtr += sizeof(VkImageLayout);
822 pDepthStencil = (VkClearDepthStencilValue*)stack_pDepthStencil;
823 reservedunmarshal_VkClearDepthStencilValue(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkClearDepthStencilValue*)(pDepthStencil), readStreamPtrPtr);
824 memcpy((uint32_t*)&rangeCount, *readStreamPtrPtr, sizeof(uint32_t));
825 *readStreamPtrPtr += sizeof(uint32_t);
826 if (((rangeCount)) <= MAX_STACK_ITEMS)
827 {
828 pRanges = (VkImageSubresourceRange*)stack_pRanges;
829 }
830 else
831 {
832 readStream->alloc((void**)&pRanges, ((rangeCount)) * sizeof(const VkImageSubresourceRange));
833 }
834 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
835 {
836 reservedunmarshal_VkImageSubresourceRange(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSubresourceRange*)(pRanges + i), readStreamPtrPtr);
837 }
838 if (pDepthStencil)
839 {
840 transform_tohost_VkClearDepthStencilValue(globalstate, (VkClearDepthStencilValue*)(pDepthStencil));
841 }
842 if (pRanges)
843 {
844 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
845 {
846 transform_tohost_VkImageSubresourceRange(globalstate, (VkImageSubresourceRange*)(pRanges + i));
847 }
848 }
849 vk->vkCmdClearDepthStencilImage((VkCommandBuffer)dispatchHandle, image, imageLayout, pDepthStencil, rangeCount, pRanges);
850 android::base::endTrace();
851 break;
852 }
853 case OP_vkCmdClearAttachments:
854 {
855 android::base::beginTrace("vkCmdClearAttachments subdecode");
856 uint32_t attachmentCount;
857 const VkClearAttachment* pAttachments;
858 VkClearAttachment stack_pAttachments[MAX_STACK_ITEMS];
859 uint32_t rectCount;
860 const VkClearRect* pRects;
861 VkClearRect stack_pRects[MAX_STACK_ITEMS];
862 memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
863 *readStreamPtrPtr += sizeof(uint32_t);
864 if (((attachmentCount)) <= MAX_STACK_ITEMS)
865 {
866 pAttachments = (VkClearAttachment*)stack_pAttachments;
867 }
868 else
869 {
870 readStream->alloc((void**)&pAttachments, ((attachmentCount)) * sizeof(const VkClearAttachment));
871 }
872 for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
873 {
874 reservedunmarshal_VkClearAttachment(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkClearAttachment*)(pAttachments + i), readStreamPtrPtr);
875 }
876 memcpy((uint32_t*)&rectCount, *readStreamPtrPtr, sizeof(uint32_t));
877 *readStreamPtrPtr += sizeof(uint32_t);
878 if (((rectCount)) <= MAX_STACK_ITEMS)
879 {
880 pRects = (VkClearRect*)stack_pRects;
881 }
882 else
883 {
884 readStream->alloc((void**)&pRects, ((rectCount)) * sizeof(const VkClearRect));
885 }
886 for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i)
887 {
888 reservedunmarshal_VkClearRect(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkClearRect*)(pRects + i), readStreamPtrPtr);
889 }
890 if (pAttachments)
891 {
892 for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
893 {
894 transform_tohost_VkClearAttachment(globalstate, (VkClearAttachment*)(pAttachments + i));
895 }
896 }
897 if (pRects)
898 {
899 for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i)
900 {
901 transform_tohost_VkClearRect(globalstate, (VkClearRect*)(pRects + i));
902 }
903 }
904 vk->vkCmdClearAttachments((VkCommandBuffer)dispatchHandle, attachmentCount, pAttachments, rectCount, pRects);
905 android::base::endTrace();
906 break;
907 }
908 case OP_vkCmdResolveImage:
909 {
910 android::base::beginTrace("vkCmdResolveImage subdecode");
911 VkImage srcImage;
912 VkImageLayout srcImageLayout;
913 VkImage dstImage;
914 VkImageLayout dstImageLayout;
915 uint32_t regionCount;
916 const VkImageResolve* pRegions;
917 VkImageResolve stack_pRegions[MAX_STACK_ITEMS];
918 uint64_t cgen_var_0;
919 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
920 *readStreamPtrPtr += 1 * 8;
921 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
922 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
923 *readStreamPtrPtr += sizeof(VkImageLayout);
924 uint64_t cgen_var_1;
925 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
926 *readStreamPtrPtr += 1 * 8;
927 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
928 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
929 *readStreamPtrPtr += sizeof(VkImageLayout);
930 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
931 *readStreamPtrPtr += sizeof(uint32_t);
932 if (((regionCount)) <= MAX_STACK_ITEMS)
933 {
934 pRegions = (VkImageResolve*)stack_pRegions;
935 }
936 else
937 {
938 readStream->alloc((void**)&pRegions, ((regionCount)) * sizeof(const VkImageResolve));
939 }
940 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
941 {
942 reservedunmarshal_VkImageResolve(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageResolve*)(pRegions + i), readStreamPtrPtr);
943 }
944 if (pRegions)
945 {
946 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
947 {
948 transform_tohost_VkImageResolve(globalstate, (VkImageResolve*)(pRegions + i));
949 }
950 }
951 vk->vkCmdResolveImage((VkCommandBuffer)dispatchHandle, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
952 android::base::endTrace();
953 break;
954 }
955 case OP_vkCmdSetEvent:
956 {
957 android::base::beginTrace("vkCmdSetEvent subdecode");
958 VkEvent event;
959 VkPipelineStageFlags stageMask;
960 uint64_t cgen_var_0;
961 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
962 *readStreamPtrPtr += 1 * 8;
963 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
964 memcpy((VkPipelineStageFlags*)&stageMask, *readStreamPtrPtr, sizeof(VkPipelineStageFlags));
965 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
966 vk->vkCmdSetEvent((VkCommandBuffer)dispatchHandle, event, stageMask);
967 android::base::endTrace();
968 break;
969 }
970 case OP_vkCmdResetEvent:
971 {
972 android::base::beginTrace("vkCmdResetEvent subdecode");
973 VkEvent event;
974 VkPipelineStageFlags stageMask;
975 uint64_t cgen_var_0;
976 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
977 *readStreamPtrPtr += 1 * 8;
978 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
979 memcpy((VkPipelineStageFlags*)&stageMask, *readStreamPtrPtr, sizeof(VkPipelineStageFlags));
980 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
981 vk->vkCmdResetEvent((VkCommandBuffer)dispatchHandle, event, stageMask);
982 android::base::endTrace();
983 break;
984 }
985 case OP_vkCmdWaitEvents:
986 {
987 android::base::beginTrace("vkCmdWaitEvents subdecode");
988 uint32_t eventCount;
989 const VkEvent* pEvents;
990 VkEvent stack_pEvents[MAX_STACK_ITEMS];
991 VkPipelineStageFlags srcStageMask;
992 VkPipelineStageFlags dstStageMask;
993 uint32_t memoryBarrierCount;
994 const VkMemoryBarrier* pMemoryBarriers;
995 VkMemoryBarrier stack_pMemoryBarriers[MAX_STACK_ITEMS];
996 uint32_t bufferMemoryBarrierCount;
997 const VkBufferMemoryBarrier* pBufferMemoryBarriers;
998 VkBufferMemoryBarrier stack_pBufferMemoryBarriers[MAX_STACK_ITEMS];
999 uint32_t imageMemoryBarrierCount;
1000 const VkImageMemoryBarrier* pImageMemoryBarriers;
1001 VkImageMemoryBarrier stack_pImageMemoryBarriers[MAX_STACK_ITEMS];
1002 memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
1003 *readStreamPtrPtr += sizeof(uint32_t);
1004 if (((eventCount)) <= MAX_STACK_ITEMS)
1005 {
1006 pEvents = (VkEvent*)stack_pEvents;
1007 }
1008 else
1009 {
1010 readStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
1011 }
1012 if (((eventCount)))
1013 {
1014 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
1015 *readStreamPtrPtr += 8 * ((eventCount));
1016 for (uint32_t k = 0; k < ((eventCount)); ++k)
1017 {
1018 uint64_t tmpval; memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
1019 *(((VkEvent*)pEvents) + k) = (VkEvent)unbox_VkEvent((VkEvent)tmpval);
1020 }
1021 }
1022 memcpy((VkPipelineStageFlags*)&srcStageMask, *readStreamPtrPtr, sizeof(VkPipelineStageFlags));
1023 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1024 memcpy((VkPipelineStageFlags*)&dstStageMask, *readStreamPtrPtr, sizeof(VkPipelineStageFlags));
1025 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1026 memcpy((uint32_t*)&memoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1027 *readStreamPtrPtr += sizeof(uint32_t);
1028 if (((memoryBarrierCount)) <= MAX_STACK_ITEMS)
1029 {
1030 pMemoryBarriers = (VkMemoryBarrier*)stack_pMemoryBarriers;
1031 }
1032 else
1033 {
1034 readStream->alloc((void**)&pMemoryBarriers, ((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
1035 }
1036 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
1037 {
1038 reservedunmarshal_VkMemoryBarrier(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryBarrier*)(pMemoryBarriers + i), readStreamPtrPtr);
1039 }
1040 memcpy((uint32_t*)&bufferMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1041 *readStreamPtrPtr += sizeof(uint32_t);
1042 if (((bufferMemoryBarrierCount)) <= MAX_STACK_ITEMS)
1043 {
1044 pBufferMemoryBarriers = (VkBufferMemoryBarrier*)stack_pBufferMemoryBarriers;
1045 }
1046 else
1047 {
1048 readStream->alloc((void**)&pBufferMemoryBarriers, ((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
1049 }
1050 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
1051 {
1052 reservedunmarshal_VkBufferMemoryBarrier(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i), readStreamPtrPtr);
1053 }
1054 memcpy((uint32_t*)&imageMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1055 *readStreamPtrPtr += sizeof(uint32_t);
1056 if (((imageMemoryBarrierCount)) <= MAX_STACK_ITEMS)
1057 {
1058 pImageMemoryBarriers = (VkImageMemoryBarrier*)stack_pImageMemoryBarriers;
1059 }
1060 else
1061 {
1062 readStream->alloc((void**)&pImageMemoryBarriers, ((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
1063 }
1064 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
1065 {
1066 reservedunmarshal_VkImageMemoryBarrier(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageMemoryBarrier*)(pImageMemoryBarriers + i), readStreamPtrPtr);
1067 }
1068 if (pMemoryBarriers)
1069 {
1070 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
1071 {
1072 transform_tohost_VkMemoryBarrier(globalstate, (VkMemoryBarrier*)(pMemoryBarriers + i));
1073 }
1074 }
1075 if (pBufferMemoryBarriers)
1076 {
1077 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
1078 {
1079 transform_tohost_VkBufferMemoryBarrier(globalstate, (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i));
1080 }
1081 }
1082 if (pImageMemoryBarriers)
1083 {
1084 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
1085 {
1086 transform_tohost_VkImageMemoryBarrier(globalstate, (VkImageMemoryBarrier*)(pImageMemoryBarriers + i));
1087 }
1088 }
1089 vk->vkCmdWaitEvents((VkCommandBuffer)dispatchHandle, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1090 android::base::endTrace();
1091 break;
1092 }
1093 case OP_vkCmdPipelineBarrier:
1094 {
1095 android::base::beginTrace("vkCmdPipelineBarrier subdecode");
1096 VkPipelineStageFlags srcStageMask;
1097 VkPipelineStageFlags dstStageMask;
1098 VkDependencyFlags dependencyFlags;
1099 uint32_t memoryBarrierCount;
1100 const VkMemoryBarrier* pMemoryBarriers;
1101 VkMemoryBarrier stack_pMemoryBarriers[MAX_STACK_ITEMS];
1102 uint32_t bufferMemoryBarrierCount;
1103 const VkBufferMemoryBarrier* pBufferMemoryBarriers;
1104 VkBufferMemoryBarrier stack_pBufferMemoryBarriers[MAX_STACK_ITEMS];
1105 uint32_t imageMemoryBarrierCount;
1106 const VkImageMemoryBarrier* pImageMemoryBarriers;
1107 VkImageMemoryBarrier stack_pImageMemoryBarriers[MAX_STACK_ITEMS];
1108 memcpy((VkPipelineStageFlags*)&srcStageMask, *readStreamPtrPtr, sizeof(VkPipelineStageFlags));
1109 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1110 memcpy((VkPipelineStageFlags*)&dstStageMask, *readStreamPtrPtr, sizeof(VkPipelineStageFlags));
1111 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1112 memcpy((VkDependencyFlags*)&dependencyFlags, *readStreamPtrPtr, sizeof(VkDependencyFlags));
1113 *readStreamPtrPtr += sizeof(VkDependencyFlags);
1114 memcpy((uint32_t*)&memoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1115 *readStreamPtrPtr += sizeof(uint32_t);
1116 if (((memoryBarrierCount)) <= MAX_STACK_ITEMS)
1117 {
1118 pMemoryBarriers = (VkMemoryBarrier*)stack_pMemoryBarriers;
1119 }
1120 else
1121 {
1122 readStream->alloc((void**)&pMemoryBarriers, ((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
1123 }
1124 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
1125 {
1126 reservedunmarshal_VkMemoryBarrier(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryBarrier*)(pMemoryBarriers + i), readStreamPtrPtr);
1127 }
1128 memcpy((uint32_t*)&bufferMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1129 *readStreamPtrPtr += sizeof(uint32_t);
1130 if (((bufferMemoryBarrierCount)) <= MAX_STACK_ITEMS)
1131 {
1132 pBufferMemoryBarriers = (VkBufferMemoryBarrier*)stack_pBufferMemoryBarriers;
1133 }
1134 else
1135 {
1136 readStream->alloc((void**)&pBufferMemoryBarriers, ((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
1137 }
1138 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
1139 {
1140 reservedunmarshal_VkBufferMemoryBarrier(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i), readStreamPtrPtr);
1141 }
1142 memcpy((uint32_t*)&imageMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1143 *readStreamPtrPtr += sizeof(uint32_t);
1144 if (((imageMemoryBarrierCount)) <= MAX_STACK_ITEMS)
1145 {
1146 pImageMemoryBarriers = (VkImageMemoryBarrier*)stack_pImageMemoryBarriers;
1147 }
1148 else
1149 {
1150 readStream->alloc((void**)&pImageMemoryBarriers, ((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
1151 }
1152 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
1153 {
1154 reservedunmarshal_VkImageMemoryBarrier(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageMemoryBarrier*)(pImageMemoryBarriers + i), readStreamPtrPtr);
1155 }
1156 if (pMemoryBarriers)
1157 {
1158 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
1159 {
1160 transform_tohost_VkMemoryBarrier(globalstate, (VkMemoryBarrier*)(pMemoryBarriers + i));
1161 }
1162 }
1163 if (pBufferMemoryBarriers)
1164 {
1165 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
1166 {
1167 transform_tohost_VkBufferMemoryBarrier(globalstate, (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i));
1168 }
1169 }
1170 if (pImageMemoryBarriers)
1171 {
1172 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
1173 {
1174 transform_tohost_VkImageMemoryBarrier(globalstate, (VkImageMemoryBarrier*)(pImageMemoryBarriers + i));
1175 }
1176 }
1177 this->on_vkCmdPipelineBarrier(pool, (VkCommandBuffer)(boxed_dispatchHandle), srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1178 android::base::endTrace();
1179 break;
1180 }
1181 case OP_vkCmdBeginQuery:
1182 {
1183 android::base::beginTrace("vkCmdBeginQuery subdecode");
1184 VkQueryPool queryPool;
1185 uint32_t query;
1186 VkQueryControlFlags flags;
1187 uint64_t cgen_var_0;
1188 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1189 *readStreamPtrPtr += 1 * 8;
1190 *(VkQueryPool*)&queryPool = (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1191 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
1192 *readStreamPtrPtr += sizeof(uint32_t);
1193 memcpy((VkQueryControlFlags*)&flags, *readStreamPtrPtr, sizeof(VkQueryControlFlags));
1194 *readStreamPtrPtr += sizeof(VkQueryControlFlags);
1195 vk->vkCmdBeginQuery((VkCommandBuffer)dispatchHandle, queryPool, query, flags);
1196 android::base::endTrace();
1197 break;
1198 }
1199 case OP_vkCmdEndQuery:
1200 {
1201 android::base::beginTrace("vkCmdEndQuery subdecode");
1202 VkQueryPool queryPool;
1203 uint32_t query;
1204 uint64_t cgen_var_0;
1205 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1206 *readStreamPtrPtr += 1 * 8;
1207 *(VkQueryPool*)&queryPool = (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1208 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
1209 *readStreamPtrPtr += sizeof(uint32_t);
1210 vk->vkCmdEndQuery((VkCommandBuffer)dispatchHandle, queryPool, query);
1211 android::base::endTrace();
1212 break;
1213 }
1214 case OP_vkCmdResetQueryPool:
1215 {
1216 android::base::beginTrace("vkCmdResetQueryPool subdecode");
1217 VkQueryPool queryPool;
1218 uint32_t firstQuery;
1219 uint32_t queryCount;
1220 uint64_t cgen_var_0;
1221 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1222 *readStreamPtrPtr += 1 * 8;
1223 *(VkQueryPool*)&queryPool = (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1224 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
1225 *readStreamPtrPtr += sizeof(uint32_t);
1226 memcpy((uint32_t*)&queryCount, *readStreamPtrPtr, sizeof(uint32_t));
1227 *readStreamPtrPtr += sizeof(uint32_t);
1228 vk->vkCmdResetQueryPool((VkCommandBuffer)dispatchHandle, queryPool, firstQuery, queryCount);
1229 android::base::endTrace();
1230 break;
1231 }
1232 case OP_vkCmdWriteTimestamp:
1233 {
1234 android::base::beginTrace("vkCmdWriteTimestamp subdecode");
1235 VkPipelineStageFlagBits pipelineStage;
1236 VkQueryPool queryPool;
1237 uint32_t query;
1238 memcpy((VkPipelineStageFlagBits*)&pipelineStage, *readStreamPtrPtr, sizeof(VkPipelineStageFlagBits));
1239 *readStreamPtrPtr += sizeof(VkPipelineStageFlagBits);
1240 uint64_t cgen_var_0;
1241 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1242 *readStreamPtrPtr += 1 * 8;
1243 *(VkQueryPool*)&queryPool = (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1244 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
1245 *readStreamPtrPtr += sizeof(uint32_t);
1246 vk->vkCmdWriteTimestamp((VkCommandBuffer)dispatchHandle, pipelineStage, queryPool, query);
1247 android::base::endTrace();
1248 break;
1249 }
1250 case OP_vkCmdCopyQueryPoolResults:
1251 {
1252 android::base::beginTrace("vkCmdCopyQueryPoolResults subdecode");
1253 VkQueryPool queryPool;
1254 uint32_t firstQuery;
1255 uint32_t queryCount;
1256 VkBuffer dstBuffer;
1257 VkDeviceSize dstOffset;
1258 VkDeviceSize stride;
1259 VkQueryResultFlags flags;
1260 uint64_t cgen_var_0;
1261 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1262 *readStreamPtrPtr += 1 * 8;
1263 *(VkQueryPool*)&queryPool = (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1264 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
1265 *readStreamPtrPtr += sizeof(uint32_t);
1266 memcpy((uint32_t*)&queryCount, *readStreamPtrPtr, sizeof(uint32_t));
1267 *readStreamPtrPtr += sizeof(uint32_t);
1268 uint64_t cgen_var_1;
1269 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1270 *readStreamPtrPtr += 1 * 8;
1271 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
1272 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1273 *readStreamPtrPtr += sizeof(VkDeviceSize);
1274 memcpy((VkDeviceSize*)&stride, *readStreamPtrPtr, sizeof(VkDeviceSize));
1275 *readStreamPtrPtr += sizeof(VkDeviceSize);
1276 memcpy((VkQueryResultFlags*)&flags, *readStreamPtrPtr, sizeof(VkQueryResultFlags));
1277 *readStreamPtrPtr += sizeof(VkQueryResultFlags);
1278 vk->vkCmdCopyQueryPoolResults((VkCommandBuffer)dispatchHandle, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
1279 android::base::endTrace();
1280 break;
1281 }
1282 case OP_vkCmdPushConstants:
1283 {
1284 android::base::beginTrace("vkCmdPushConstants subdecode");
1285 VkPipelineLayout layout;
1286 VkShaderStageFlags stageFlags;
1287 uint32_t offset;
1288 uint32_t size;
1289 const void* pValues;
1290 uint8_t* stack_pValues[MAX_STACK_ITEMS];
1291 uint64_t cgen_var_0;
1292 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1293 *readStreamPtrPtr += 1 * 8;
1294 *(VkPipelineLayout*)&layout = (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
1295 memcpy((VkShaderStageFlags*)&stageFlags, *readStreamPtrPtr, sizeof(VkShaderStageFlags));
1296 *readStreamPtrPtr += sizeof(VkShaderStageFlags);
1297 memcpy((uint32_t*)&offset, *readStreamPtrPtr, sizeof(uint32_t));
1298 *readStreamPtrPtr += sizeof(uint32_t);
1299 memcpy((uint32_t*)&size, *readStreamPtrPtr, sizeof(uint32_t));
1300 *readStreamPtrPtr += sizeof(uint32_t);
1301 if (((size)) <= MAX_STACK_ITEMS)
1302 {
1303 pValues = (void*)stack_pValues;
1304 }
1305 else
1306 {
1307 readStream->alloc((void**)&pValues, ((size)) * sizeof(const uint8_t));
1308 }
1309 memcpy((void*)pValues, *readStreamPtrPtr, ((size)) * sizeof(const uint8_t));
1310 *readStreamPtrPtr += ((size)) * sizeof(const uint8_t);
1311 vk->vkCmdPushConstants((VkCommandBuffer)dispatchHandle, layout, stageFlags, offset, size, pValues);
1312 android::base::endTrace();
1313 break;
1314 }
1315 case OP_vkCmdBeginRenderPass:
1316 {
1317 android::base::beginTrace("vkCmdBeginRenderPass subdecode");
1318 const VkRenderPassBeginInfo* pRenderPassBegin;
1319 VkRenderPassBeginInfo stack_pRenderPassBegin[1];
1320 VkSubpassContents contents;
1321 pRenderPassBegin = (VkRenderPassBeginInfo*)stack_pRenderPassBegin;
1322 reservedunmarshal_VkRenderPassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderPassBeginInfo*)(pRenderPassBegin), readStreamPtrPtr);
1323 memcpy((VkSubpassContents*)&contents, *readStreamPtrPtr, sizeof(VkSubpassContents));
1324 *readStreamPtrPtr += sizeof(VkSubpassContents);
1325 if (pRenderPassBegin)
1326 {
1327 transform_tohost_VkRenderPassBeginInfo(globalstate, (VkRenderPassBeginInfo*)(pRenderPassBegin));
1328 }
1329 vk->vkCmdBeginRenderPass((VkCommandBuffer)dispatchHandle, pRenderPassBegin, contents);
1330 android::base::endTrace();
1331 break;
1332 }
1333 case OP_vkCmdNextSubpass:
1334 {
1335 android::base::beginTrace("vkCmdNextSubpass subdecode");
1336 VkSubpassContents contents;
1337 memcpy((VkSubpassContents*)&contents, *readStreamPtrPtr, sizeof(VkSubpassContents));
1338 *readStreamPtrPtr += sizeof(VkSubpassContents);
1339 vk->vkCmdNextSubpass((VkCommandBuffer)dispatchHandle, contents);
1340 android::base::endTrace();
1341 break;
1342 }
1343 case OP_vkCmdEndRenderPass:
1344 {
1345 android::base::beginTrace("vkCmdEndRenderPass subdecode");
1346 vk->vkCmdEndRenderPass((VkCommandBuffer)dispatchHandle);
1347 android::base::endTrace();
1348 break;
1349 }
1350 case OP_vkCmdExecuteCommands:
1351 {
1352 android::base::beginTrace("vkCmdExecuteCommands subdecode");
1353 uint32_t commandBufferCount;
1354 const VkCommandBuffer* pCommandBuffers;
1355 VkCommandBuffer stack_pCommandBuffers[MAX_STACK_ITEMS];
1356 memcpy((uint32_t*)&commandBufferCount, *readStreamPtrPtr, sizeof(uint32_t));
1357 *readStreamPtrPtr += sizeof(uint32_t);
1358 if (((commandBufferCount)) <= MAX_STACK_ITEMS)
1359 {
1360 pCommandBuffers = (VkCommandBuffer*)stack_pCommandBuffers;
1361 }
1362 else
1363 {
1364 readStream->alloc((void**)&pCommandBuffers, ((commandBufferCount)) * sizeof(const VkCommandBuffer));
1365 }
1366 if (((commandBufferCount)))
1367 {
1368 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
1369 *readStreamPtrPtr += 8 * ((commandBufferCount));
1370 for (uint32_t k = 0; k < ((commandBufferCount)); ++k)
1371 {
1372 uint64_t tmpval; memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
1373 *(((VkCommandBuffer*)pCommandBuffers) + k) = (VkCommandBuffer)unbox_VkCommandBuffer((VkCommandBuffer)tmpval);
1374 }
1375 }
1376 this->on_vkCmdExecuteCommands(pool, (VkCommandBuffer)(boxed_dispatchHandle), commandBufferCount, pCommandBuffers);
1377 android::base::endTrace();
1378 break;
1379 }
1380 #endif
1381 #ifdef VK_VERSION_1_1
1382 case OP_vkCmdSetDeviceMask:
1383 {
1384 android::base::beginTrace("vkCmdSetDeviceMask subdecode");
1385 uint32_t deviceMask;
1386 memcpy((uint32_t*)&deviceMask, *readStreamPtrPtr, sizeof(uint32_t));
1387 *readStreamPtrPtr += sizeof(uint32_t);
1388 vk->vkCmdSetDeviceMask((VkCommandBuffer)dispatchHandle, deviceMask);
1389 android::base::endTrace();
1390 break;
1391 }
1392 case OP_vkCmdDispatchBase:
1393 {
1394 android::base::beginTrace("vkCmdDispatchBase subdecode");
1395 uint32_t baseGroupX;
1396 uint32_t baseGroupY;
1397 uint32_t baseGroupZ;
1398 uint32_t groupCountX;
1399 uint32_t groupCountY;
1400 uint32_t groupCountZ;
1401 memcpy((uint32_t*)&baseGroupX, *readStreamPtrPtr, sizeof(uint32_t));
1402 *readStreamPtrPtr += sizeof(uint32_t);
1403 memcpy((uint32_t*)&baseGroupY, *readStreamPtrPtr, sizeof(uint32_t));
1404 *readStreamPtrPtr += sizeof(uint32_t);
1405 memcpy((uint32_t*)&baseGroupZ, *readStreamPtrPtr, sizeof(uint32_t));
1406 *readStreamPtrPtr += sizeof(uint32_t);
1407 memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
1408 *readStreamPtrPtr += sizeof(uint32_t);
1409 memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
1410 *readStreamPtrPtr += sizeof(uint32_t);
1411 memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
1412 *readStreamPtrPtr += sizeof(uint32_t);
1413 vk->vkCmdDispatchBase((VkCommandBuffer)dispatchHandle, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
1414 android::base::endTrace();
1415 break;
1416 }
1417 #endif
1418 #ifdef VK_VERSION_1_2
1419 case OP_vkCmdDrawIndirectCount:
1420 {
1421 android::base::beginTrace("vkCmdDrawIndirectCount subdecode");
1422 VkBuffer buffer;
1423 VkDeviceSize offset;
1424 VkBuffer countBuffer;
1425 VkDeviceSize countBufferOffset;
1426 uint32_t maxDrawCount;
1427 uint32_t stride;
1428 uint64_t cgen_var_0;
1429 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1430 *readStreamPtrPtr += 1 * 8;
1431 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
1432 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1433 *readStreamPtrPtr += sizeof(VkDeviceSize);
1434 uint64_t cgen_var_1;
1435 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1436 *readStreamPtrPtr += 1 * 8;
1437 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
1438 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1439 *readStreamPtrPtr += sizeof(VkDeviceSize);
1440 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
1441 *readStreamPtrPtr += sizeof(uint32_t);
1442 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
1443 *readStreamPtrPtr += sizeof(uint32_t);
1444 vk->vkCmdDrawIndirectCount((VkCommandBuffer)dispatchHandle, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1445 android::base::endTrace();
1446 break;
1447 }
1448 case OP_vkCmdDrawIndexedIndirectCount:
1449 {
1450 android::base::beginTrace("vkCmdDrawIndexedIndirectCount subdecode");
1451 VkBuffer buffer;
1452 VkDeviceSize offset;
1453 VkBuffer countBuffer;
1454 VkDeviceSize countBufferOffset;
1455 uint32_t maxDrawCount;
1456 uint32_t stride;
1457 uint64_t cgen_var_0;
1458 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1459 *readStreamPtrPtr += 1 * 8;
1460 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
1461 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1462 *readStreamPtrPtr += sizeof(VkDeviceSize);
1463 uint64_t cgen_var_1;
1464 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1465 *readStreamPtrPtr += 1 * 8;
1466 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
1467 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1468 *readStreamPtrPtr += sizeof(VkDeviceSize);
1469 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
1470 *readStreamPtrPtr += sizeof(uint32_t);
1471 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
1472 *readStreamPtrPtr += sizeof(uint32_t);
1473 vk->vkCmdDrawIndexedIndirectCount((VkCommandBuffer)dispatchHandle, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1474 android::base::endTrace();
1475 break;
1476 }
1477 case OP_vkCmdBeginRenderPass2:
1478 {
1479 android::base::beginTrace("vkCmdBeginRenderPass2 subdecode");
1480 const VkRenderPassBeginInfo* pRenderPassBegin;
1481 VkRenderPassBeginInfo stack_pRenderPassBegin[1];
1482 const VkSubpassBeginInfo* pSubpassBeginInfo;
1483 VkSubpassBeginInfo stack_pSubpassBeginInfo[1];
1484 pRenderPassBegin = (VkRenderPassBeginInfo*)stack_pRenderPassBegin;
1485 reservedunmarshal_VkRenderPassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderPassBeginInfo*)(pRenderPassBegin), readStreamPtrPtr);
1486 pSubpassBeginInfo = (VkSubpassBeginInfo*)stack_pSubpassBeginInfo;
1487 reservedunmarshal_VkSubpassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassBeginInfo*)(pSubpassBeginInfo), readStreamPtrPtr);
1488 if (pRenderPassBegin)
1489 {
1490 transform_tohost_VkRenderPassBeginInfo(globalstate, (VkRenderPassBeginInfo*)(pRenderPassBegin));
1491 }
1492 if (pSubpassBeginInfo)
1493 {
1494 transform_tohost_VkSubpassBeginInfo(globalstate, (VkSubpassBeginInfo*)(pSubpassBeginInfo));
1495 }
1496 vk->vkCmdBeginRenderPass2((VkCommandBuffer)dispatchHandle, pRenderPassBegin, pSubpassBeginInfo);
1497 android::base::endTrace();
1498 break;
1499 }
1500 case OP_vkCmdNextSubpass2:
1501 {
1502 android::base::beginTrace("vkCmdNextSubpass2 subdecode");
1503 const VkSubpassBeginInfo* pSubpassBeginInfo;
1504 VkSubpassBeginInfo stack_pSubpassBeginInfo[1];
1505 const VkSubpassEndInfo* pSubpassEndInfo;
1506 VkSubpassEndInfo stack_pSubpassEndInfo[1];
1507 pSubpassBeginInfo = (VkSubpassBeginInfo*)stack_pSubpassBeginInfo;
1508 reservedunmarshal_VkSubpassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassBeginInfo*)(pSubpassBeginInfo), readStreamPtrPtr);
1509 pSubpassEndInfo = (VkSubpassEndInfo*)stack_pSubpassEndInfo;
1510 reservedunmarshal_VkSubpassEndInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassEndInfo*)(pSubpassEndInfo), readStreamPtrPtr);
1511 if (pSubpassBeginInfo)
1512 {
1513 transform_tohost_VkSubpassBeginInfo(globalstate, (VkSubpassBeginInfo*)(pSubpassBeginInfo));
1514 }
1515 if (pSubpassEndInfo)
1516 {
1517 transform_tohost_VkSubpassEndInfo(globalstate, (VkSubpassEndInfo*)(pSubpassEndInfo));
1518 }
1519 vk->vkCmdNextSubpass2((VkCommandBuffer)dispatchHandle, pSubpassBeginInfo, pSubpassEndInfo);
1520 android::base::endTrace();
1521 break;
1522 }
1523 case OP_vkCmdEndRenderPass2:
1524 {
1525 android::base::beginTrace("vkCmdEndRenderPass2 subdecode");
1526 const VkSubpassEndInfo* pSubpassEndInfo;
1527 VkSubpassEndInfo stack_pSubpassEndInfo[1];
1528 pSubpassEndInfo = (VkSubpassEndInfo*)stack_pSubpassEndInfo;
1529 reservedunmarshal_VkSubpassEndInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassEndInfo*)(pSubpassEndInfo), readStreamPtrPtr);
1530 if (pSubpassEndInfo)
1531 {
1532 transform_tohost_VkSubpassEndInfo(globalstate, (VkSubpassEndInfo*)(pSubpassEndInfo));
1533 }
1534 vk->vkCmdEndRenderPass2((VkCommandBuffer)dispatchHandle, pSubpassEndInfo);
1535 android::base::endTrace();
1536 break;
1537 }
1538 #endif
1539 #ifdef VK_KHR_surface
1540 #endif
1541 #ifdef VK_KHR_swapchain
1542 #endif
1543 #ifdef VK_KHR_display
1544 #endif
1545 #ifdef VK_KHR_display_swapchain
1546 #endif
1547 #ifdef VK_KHR_xlib_surface
1548 #endif
1549 #ifdef VK_KHR_xcb_surface
1550 #endif
1551 #ifdef VK_KHR_wayland_surface
1552 #endif
1553 #ifdef VK_KHR_android_surface
1554 #endif
1555 #ifdef VK_KHR_win32_surface
1556 #endif
1557 #ifdef VK_KHR_sampler_mirror_clamp_to_edge
1558 #endif
1559 #ifdef VK_KHR_multiview
1560 #endif
1561 #ifdef VK_KHR_get_physical_device_properties2
1562 #endif
1563 #ifdef VK_KHR_device_group
1564 case OP_vkCmdSetDeviceMaskKHR:
1565 {
1566 android::base::beginTrace("vkCmdSetDeviceMaskKHR subdecode");
1567 uint32_t deviceMask;
1568 memcpy((uint32_t*)&deviceMask, *readStreamPtrPtr, sizeof(uint32_t));
1569 *readStreamPtrPtr += sizeof(uint32_t);
1570 vk->vkCmdSetDeviceMaskKHR((VkCommandBuffer)dispatchHandle, deviceMask);
1571 android::base::endTrace();
1572 break;
1573 }
1574 case OP_vkCmdDispatchBaseKHR:
1575 {
1576 android::base::beginTrace("vkCmdDispatchBaseKHR subdecode");
1577 uint32_t baseGroupX;
1578 uint32_t baseGroupY;
1579 uint32_t baseGroupZ;
1580 uint32_t groupCountX;
1581 uint32_t groupCountY;
1582 uint32_t groupCountZ;
1583 memcpy((uint32_t*)&baseGroupX, *readStreamPtrPtr, sizeof(uint32_t));
1584 *readStreamPtrPtr += sizeof(uint32_t);
1585 memcpy((uint32_t*)&baseGroupY, *readStreamPtrPtr, sizeof(uint32_t));
1586 *readStreamPtrPtr += sizeof(uint32_t);
1587 memcpy((uint32_t*)&baseGroupZ, *readStreamPtrPtr, sizeof(uint32_t));
1588 *readStreamPtrPtr += sizeof(uint32_t);
1589 memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
1590 *readStreamPtrPtr += sizeof(uint32_t);
1591 memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
1592 *readStreamPtrPtr += sizeof(uint32_t);
1593 memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
1594 *readStreamPtrPtr += sizeof(uint32_t);
1595 vk->vkCmdDispatchBaseKHR((VkCommandBuffer)dispatchHandle, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
1596 android::base::endTrace();
1597 break;
1598 }
1599 #endif
1600 #ifdef VK_KHR_shader_draw_parameters
1601 #endif
1602 #ifdef VK_KHR_maintenance1
1603 #endif
1604 #ifdef VK_KHR_device_group_creation
1605 #endif
1606 #ifdef VK_KHR_external_memory_capabilities
1607 #endif
1608 #ifdef VK_KHR_external_memory
1609 #endif
1610 #ifdef VK_KHR_external_memory_win32
1611 #endif
1612 #ifdef VK_KHR_external_memory_fd
1613 #endif
1614 #ifdef VK_KHR_win32_keyed_mutex
1615 #endif
1616 #ifdef VK_KHR_external_semaphore_capabilities
1617 #endif
1618 #ifdef VK_KHR_external_semaphore
1619 #endif
1620 #ifdef VK_KHR_external_semaphore_win32
1621 #endif
1622 #ifdef VK_KHR_external_semaphore_fd
1623 #endif
1624 #ifdef VK_KHR_push_descriptor
1625 case OP_vkCmdPushDescriptorSetKHR:
1626 {
1627 android::base::beginTrace("vkCmdPushDescriptorSetKHR subdecode");
1628 VkPipelineBindPoint pipelineBindPoint;
1629 VkPipelineLayout layout;
1630 uint32_t set;
1631 uint32_t descriptorWriteCount;
1632 const VkWriteDescriptorSet* pDescriptorWrites;
1633 VkWriteDescriptorSet stack_pDescriptorWrites[MAX_STACK_ITEMS];
1634 memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr, sizeof(VkPipelineBindPoint));
1635 *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
1636 uint64_t cgen_var_0;
1637 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1638 *readStreamPtrPtr += 1 * 8;
1639 *(VkPipelineLayout*)&layout = (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
1640 memcpy((uint32_t*)&set, *readStreamPtrPtr, sizeof(uint32_t));
1641 *readStreamPtrPtr += sizeof(uint32_t);
1642 memcpy((uint32_t*)&descriptorWriteCount, *readStreamPtrPtr, sizeof(uint32_t));
1643 *readStreamPtrPtr += sizeof(uint32_t);
1644 if (((descriptorWriteCount)) <= MAX_STACK_ITEMS)
1645 {
1646 pDescriptorWrites = (VkWriteDescriptorSet*)stack_pDescriptorWrites;
1647 }
1648 else
1649 {
1650 readStream->alloc((void**)&pDescriptorWrites, ((descriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
1651 }
1652 for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
1653 {
1654 reservedunmarshal_VkWriteDescriptorSet(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkWriteDescriptorSet*)(pDescriptorWrites + i), readStreamPtrPtr);
1655 }
1656 if (pDescriptorWrites)
1657 {
1658 for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
1659 {
1660 transform_tohost_VkWriteDescriptorSet(globalstate, (VkWriteDescriptorSet*)(pDescriptorWrites + i));
1661 }
1662 }
1663 vk->vkCmdPushDescriptorSetKHR((VkCommandBuffer)dispatchHandle, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
1664 android::base::endTrace();
1665 break;
1666 }
1667 case OP_vkCmdPushDescriptorSetWithTemplateKHR:
1668 {
1669 android::base::beginTrace("vkCmdPushDescriptorSetWithTemplateKHR subdecode");
1670 VkDescriptorUpdateTemplate descriptorUpdateTemplate;
1671 VkPipelineLayout layout;
1672 uint32_t set;
1673 const void* pData;
1674 uint8_t* stack_pData[1];
1675 uint64_t cgen_var_0;
1676 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1677 *readStreamPtrPtr += 1 * 8;
1678 *(VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)unbox_VkDescriptorUpdateTemplate((VkDescriptorUpdateTemplate)(*&cgen_var_0));
1679 uint64_t cgen_var_1;
1680 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1681 *readStreamPtrPtr += 1 * 8;
1682 *(VkPipelineLayout*)&layout = (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_1));
1683 memcpy((uint32_t*)&set, *readStreamPtrPtr, sizeof(uint32_t));
1684 *readStreamPtrPtr += sizeof(uint32_t);
1685 // WARNING PTR CHECK
1686 memcpy((void**)&pData, (*readStreamPtrPtr), 8);
1687 android::base::Stream::fromBe64((uint8_t*)&pData);
1688 *readStreamPtrPtr += 8;
1689 if (pData)
1690 {
1691 pData = (void*)stack_pData;
1692 memcpy((void*)pData, *readStreamPtrPtr, sizeof(const uint8_t));
1693 *readStreamPtrPtr += sizeof(const uint8_t);
1694 }
1695 vk->vkCmdPushDescriptorSetWithTemplateKHR((VkCommandBuffer)dispatchHandle, descriptorUpdateTemplate, layout, set, pData);
1696 android::base::endTrace();
1697 break;
1698 }
1699 #endif
1700 #ifdef VK_KHR_shader_float16_int8
1701 #endif
1702 #ifdef VK_KHR_16bit_storage
1703 #endif
1704 #ifdef VK_KHR_incremental_present
1705 #endif
1706 #ifdef VK_KHR_descriptor_update_template
1707 #endif
1708 #ifdef VK_KHR_imageless_framebuffer
1709 #endif
1710 #ifdef VK_KHR_create_renderpass2
1711 case OP_vkCmdBeginRenderPass2KHR:
1712 {
1713 android::base::beginTrace("vkCmdBeginRenderPass2KHR subdecode");
1714 const VkRenderPassBeginInfo* pRenderPassBegin;
1715 VkRenderPassBeginInfo stack_pRenderPassBegin[1];
1716 const VkSubpassBeginInfo* pSubpassBeginInfo;
1717 VkSubpassBeginInfo stack_pSubpassBeginInfo[1];
1718 pRenderPassBegin = (VkRenderPassBeginInfo*)stack_pRenderPassBegin;
1719 reservedunmarshal_VkRenderPassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderPassBeginInfo*)(pRenderPassBegin), readStreamPtrPtr);
1720 pSubpassBeginInfo = (VkSubpassBeginInfo*)stack_pSubpassBeginInfo;
1721 reservedunmarshal_VkSubpassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassBeginInfo*)(pSubpassBeginInfo), readStreamPtrPtr);
1722 if (pRenderPassBegin)
1723 {
1724 transform_tohost_VkRenderPassBeginInfo(globalstate, (VkRenderPassBeginInfo*)(pRenderPassBegin));
1725 }
1726 if (pSubpassBeginInfo)
1727 {
1728 transform_tohost_VkSubpassBeginInfo(globalstate, (VkSubpassBeginInfo*)(pSubpassBeginInfo));
1729 }
1730 vk->vkCmdBeginRenderPass2KHR((VkCommandBuffer)dispatchHandle, pRenderPassBegin, pSubpassBeginInfo);
1731 android::base::endTrace();
1732 break;
1733 }
1734 case OP_vkCmdNextSubpass2KHR:
1735 {
1736 android::base::beginTrace("vkCmdNextSubpass2KHR subdecode");
1737 const VkSubpassBeginInfo* pSubpassBeginInfo;
1738 VkSubpassBeginInfo stack_pSubpassBeginInfo[1];
1739 const VkSubpassEndInfo* pSubpassEndInfo;
1740 VkSubpassEndInfo stack_pSubpassEndInfo[1];
1741 pSubpassBeginInfo = (VkSubpassBeginInfo*)stack_pSubpassBeginInfo;
1742 reservedunmarshal_VkSubpassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassBeginInfo*)(pSubpassBeginInfo), readStreamPtrPtr);
1743 pSubpassEndInfo = (VkSubpassEndInfo*)stack_pSubpassEndInfo;
1744 reservedunmarshal_VkSubpassEndInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassEndInfo*)(pSubpassEndInfo), readStreamPtrPtr);
1745 if (pSubpassBeginInfo)
1746 {
1747 transform_tohost_VkSubpassBeginInfo(globalstate, (VkSubpassBeginInfo*)(pSubpassBeginInfo));
1748 }
1749 if (pSubpassEndInfo)
1750 {
1751 transform_tohost_VkSubpassEndInfo(globalstate, (VkSubpassEndInfo*)(pSubpassEndInfo));
1752 }
1753 vk->vkCmdNextSubpass2KHR((VkCommandBuffer)dispatchHandle, pSubpassBeginInfo, pSubpassEndInfo);
1754 android::base::endTrace();
1755 break;
1756 }
1757 case OP_vkCmdEndRenderPass2KHR:
1758 {
1759 android::base::beginTrace("vkCmdEndRenderPass2KHR subdecode");
1760 const VkSubpassEndInfo* pSubpassEndInfo;
1761 VkSubpassEndInfo stack_pSubpassEndInfo[1];
1762 pSubpassEndInfo = (VkSubpassEndInfo*)stack_pSubpassEndInfo;
1763 reservedunmarshal_VkSubpassEndInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassEndInfo*)(pSubpassEndInfo), readStreamPtrPtr);
1764 if (pSubpassEndInfo)
1765 {
1766 transform_tohost_VkSubpassEndInfo(globalstate, (VkSubpassEndInfo*)(pSubpassEndInfo));
1767 }
1768 vk->vkCmdEndRenderPass2KHR((VkCommandBuffer)dispatchHandle, pSubpassEndInfo);
1769 android::base::endTrace();
1770 break;
1771 }
1772 #endif
1773 #ifdef VK_KHR_shared_presentable_image
1774 #endif
1775 #ifdef VK_KHR_external_fence_capabilities
1776 #endif
1777 #ifdef VK_KHR_external_fence
1778 #endif
1779 #ifdef VK_KHR_external_fence_win32
1780 #endif
1781 #ifdef VK_KHR_external_fence_fd
1782 #endif
1783 #ifdef VK_KHR_performance_query
1784 #endif
1785 #ifdef VK_KHR_maintenance2
1786 #endif
1787 #ifdef VK_KHR_get_surface_capabilities2
1788 #endif
1789 #ifdef VK_KHR_variable_pointers
1790 #endif
1791 #ifdef VK_KHR_get_display_properties2
1792 #endif
1793 #ifdef VK_KHR_dedicated_allocation
1794 #endif
1795 #ifdef VK_KHR_storage_buffer_storage_class
1796 #endif
1797 #ifdef VK_KHR_relaxed_block_layout
1798 #endif
1799 #ifdef VK_KHR_get_memory_requirements2
1800 #endif
1801 #ifdef VK_KHR_image_format_list
1802 #endif
1803 #ifdef VK_KHR_sampler_ycbcr_conversion
1804 #endif
1805 #ifdef VK_KHR_bind_memory2
1806 #endif
1807 #ifdef VK_KHR_portability_subset
1808 #endif
1809 #ifdef VK_KHR_maintenance3
1810 #endif
1811 #ifdef VK_KHR_draw_indirect_count
1812 case OP_vkCmdDrawIndirectCountKHR:
1813 {
1814 android::base::beginTrace("vkCmdDrawIndirectCountKHR subdecode");
1815 VkBuffer buffer;
1816 VkDeviceSize offset;
1817 VkBuffer countBuffer;
1818 VkDeviceSize countBufferOffset;
1819 uint32_t maxDrawCount;
1820 uint32_t stride;
1821 uint64_t cgen_var_0;
1822 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1823 *readStreamPtrPtr += 1 * 8;
1824 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
1825 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1826 *readStreamPtrPtr += sizeof(VkDeviceSize);
1827 uint64_t cgen_var_1;
1828 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1829 *readStreamPtrPtr += 1 * 8;
1830 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
1831 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1832 *readStreamPtrPtr += sizeof(VkDeviceSize);
1833 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
1834 *readStreamPtrPtr += sizeof(uint32_t);
1835 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
1836 *readStreamPtrPtr += sizeof(uint32_t);
1837 vk->vkCmdDrawIndirectCountKHR((VkCommandBuffer)dispatchHandle, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1838 android::base::endTrace();
1839 break;
1840 }
1841 case OP_vkCmdDrawIndexedIndirectCountKHR:
1842 {
1843 android::base::beginTrace("vkCmdDrawIndexedIndirectCountKHR subdecode");
1844 VkBuffer buffer;
1845 VkDeviceSize offset;
1846 VkBuffer countBuffer;
1847 VkDeviceSize countBufferOffset;
1848 uint32_t maxDrawCount;
1849 uint32_t stride;
1850 uint64_t cgen_var_0;
1851 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1852 *readStreamPtrPtr += 1 * 8;
1853 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
1854 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1855 *readStreamPtrPtr += sizeof(VkDeviceSize);
1856 uint64_t cgen_var_1;
1857 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1858 *readStreamPtrPtr += 1 * 8;
1859 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
1860 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1861 *readStreamPtrPtr += sizeof(VkDeviceSize);
1862 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
1863 *readStreamPtrPtr += sizeof(uint32_t);
1864 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
1865 *readStreamPtrPtr += sizeof(uint32_t);
1866 vk->vkCmdDrawIndexedIndirectCountKHR((VkCommandBuffer)dispatchHandle, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1867 android::base::endTrace();
1868 break;
1869 }
1870 #endif
1871 #ifdef VK_KHR_shader_subgroup_extended_types
1872 #endif
1873 #ifdef VK_KHR_8bit_storage
1874 #endif
1875 #ifdef VK_KHR_shader_atomic_int64
1876 #endif
1877 #ifdef VK_KHR_shader_clock
1878 #endif
1879 #ifdef VK_KHR_driver_properties
1880 #endif
1881 #ifdef VK_KHR_shader_float_controls
1882 #endif
1883 #ifdef VK_KHR_depth_stencil_resolve
1884 #endif
1885 #ifdef VK_KHR_swapchain_mutable_format
1886 #endif
1887 #ifdef VK_KHR_timeline_semaphore
1888 #endif
1889 #ifdef VK_KHR_vulkan_memory_model
1890 #endif
1891 #ifdef VK_KHR_shader_terminate_invocation
1892 #endif
1893 #ifdef VK_KHR_fragment_shading_rate
1894 case OP_vkCmdSetFragmentShadingRateKHR:
1895 {
1896 android::base::beginTrace("vkCmdSetFragmentShadingRateKHR subdecode");
1897 const VkExtent2D* pFragmentSize;
1898 VkExtent2D stack_pFragmentSize[1];
1899 VkFragmentShadingRateCombinerOpKHR combinerOps[2];
1900 pFragmentSize = (VkExtent2D*)stack_pFragmentSize;
1901 reservedunmarshal_VkExtent2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pFragmentSize), readStreamPtrPtr);
1902 memcpy((VkFragmentShadingRateCombinerOpKHR*)combinerOps, *readStreamPtrPtr, 2 * sizeof(const VkFragmentShadingRateCombinerOpKHR));
1903 *readStreamPtrPtr += 2 * sizeof(const VkFragmentShadingRateCombinerOpKHR);
1904 if (pFragmentSize)
1905 {
1906 transform_tohost_VkExtent2D(globalstate, (VkExtent2D*)(pFragmentSize));
1907 }
1908 vk->vkCmdSetFragmentShadingRateKHR((VkCommandBuffer)dispatchHandle, pFragmentSize, combinerOps);
1909 android::base::endTrace();
1910 break;
1911 }
1912 #endif
1913 #ifdef VK_KHR_spirv_1_4
1914 #endif
1915 #ifdef VK_KHR_surface_protected_capabilities
1916 #endif
1917 #ifdef VK_KHR_separate_depth_stencil_layouts
1918 #endif
1919 #ifdef VK_KHR_uniform_buffer_standard_layout
1920 #endif
1921 #ifdef VK_KHR_buffer_device_address
1922 #endif
1923 #ifdef VK_KHR_deferred_host_operations
1924 #endif
1925 #ifdef VK_KHR_pipeline_executable_properties
1926 #endif
1927 #ifdef VK_KHR_pipeline_library
1928 #endif
1929 #ifdef VK_KHR_shader_non_semantic_info
1930 #endif
1931 #ifdef VK_KHR_copy_commands2
1932 case OP_vkCmdCopyBuffer2KHR:
1933 {
1934 android::base::beginTrace("vkCmdCopyBuffer2KHR subdecode");
1935 const VkCopyBufferInfo2KHR* pCopyBufferInfo;
1936 VkCopyBufferInfo2KHR stack_pCopyBufferInfo[1];
1937 pCopyBufferInfo = (VkCopyBufferInfo2KHR*)stack_pCopyBufferInfo;
1938 reservedunmarshal_VkCopyBufferInfo2KHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyBufferInfo2KHR*)(pCopyBufferInfo), readStreamPtrPtr);
1939 if (pCopyBufferInfo)
1940 {
1941 transform_tohost_VkCopyBufferInfo2KHR(globalstate, (VkCopyBufferInfo2KHR*)(pCopyBufferInfo));
1942 }
1943 vk->vkCmdCopyBuffer2KHR((VkCommandBuffer)dispatchHandle, pCopyBufferInfo);
1944 android::base::endTrace();
1945 break;
1946 }
1947 case OP_vkCmdCopyImage2KHR:
1948 {
1949 android::base::beginTrace("vkCmdCopyImage2KHR subdecode");
1950 const VkCopyImageInfo2KHR* pCopyImageInfo;
1951 VkCopyImageInfo2KHR stack_pCopyImageInfo[1];
1952 pCopyImageInfo = (VkCopyImageInfo2KHR*)stack_pCopyImageInfo;
1953 reservedunmarshal_VkCopyImageInfo2KHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyImageInfo2KHR*)(pCopyImageInfo), readStreamPtrPtr);
1954 if (pCopyImageInfo)
1955 {
1956 transform_tohost_VkCopyImageInfo2KHR(globalstate, (VkCopyImageInfo2KHR*)(pCopyImageInfo));
1957 }
1958 vk->vkCmdCopyImage2KHR((VkCommandBuffer)dispatchHandle, pCopyImageInfo);
1959 android::base::endTrace();
1960 break;
1961 }
1962 case OP_vkCmdCopyBufferToImage2KHR:
1963 {
1964 android::base::beginTrace("vkCmdCopyBufferToImage2KHR subdecode");
1965 const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo;
1966 VkCopyBufferToImageInfo2KHR stack_pCopyBufferToImageInfo[1];
1967 pCopyBufferToImageInfo = (VkCopyBufferToImageInfo2KHR*)stack_pCopyBufferToImageInfo;
1968 reservedunmarshal_VkCopyBufferToImageInfo2KHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyBufferToImageInfo2KHR*)(pCopyBufferToImageInfo), readStreamPtrPtr);
1969 if (pCopyBufferToImageInfo)
1970 {
1971 transform_tohost_VkCopyBufferToImageInfo2KHR(globalstate, (VkCopyBufferToImageInfo2KHR*)(pCopyBufferToImageInfo));
1972 }
1973 vk->vkCmdCopyBufferToImage2KHR((VkCommandBuffer)dispatchHandle, pCopyBufferToImageInfo);
1974 android::base::endTrace();
1975 break;
1976 }
1977 case OP_vkCmdCopyImageToBuffer2KHR:
1978 {
1979 android::base::beginTrace("vkCmdCopyImageToBuffer2KHR subdecode");
1980 const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo;
1981 VkCopyImageToBufferInfo2KHR stack_pCopyImageToBufferInfo[1];
1982 pCopyImageToBufferInfo = (VkCopyImageToBufferInfo2KHR*)stack_pCopyImageToBufferInfo;
1983 reservedunmarshal_VkCopyImageToBufferInfo2KHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyImageToBufferInfo2KHR*)(pCopyImageToBufferInfo), readStreamPtrPtr);
1984 if (pCopyImageToBufferInfo)
1985 {
1986 transform_tohost_VkCopyImageToBufferInfo2KHR(globalstate, (VkCopyImageToBufferInfo2KHR*)(pCopyImageToBufferInfo));
1987 }
1988 vk->vkCmdCopyImageToBuffer2KHR((VkCommandBuffer)dispatchHandle, pCopyImageToBufferInfo);
1989 android::base::endTrace();
1990 break;
1991 }
1992 case OP_vkCmdBlitImage2KHR:
1993 {
1994 android::base::beginTrace("vkCmdBlitImage2KHR subdecode");
1995 const VkBlitImageInfo2KHR* pBlitImageInfo;
1996 VkBlitImageInfo2KHR stack_pBlitImageInfo[1];
1997 pBlitImageInfo = (VkBlitImageInfo2KHR*)stack_pBlitImageInfo;
1998 reservedunmarshal_VkBlitImageInfo2KHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBlitImageInfo2KHR*)(pBlitImageInfo), readStreamPtrPtr);
1999 if (pBlitImageInfo)
2000 {
2001 transform_tohost_VkBlitImageInfo2KHR(globalstate, (VkBlitImageInfo2KHR*)(pBlitImageInfo));
2002 }
2003 vk->vkCmdBlitImage2KHR((VkCommandBuffer)dispatchHandle, pBlitImageInfo);
2004 android::base::endTrace();
2005 break;
2006 }
2007 case OP_vkCmdResolveImage2KHR:
2008 {
2009 android::base::beginTrace("vkCmdResolveImage2KHR subdecode");
2010 const VkResolveImageInfo2KHR* pResolveImageInfo;
2011 VkResolveImageInfo2KHR stack_pResolveImageInfo[1];
2012 pResolveImageInfo = (VkResolveImageInfo2KHR*)stack_pResolveImageInfo;
2013 reservedunmarshal_VkResolveImageInfo2KHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkResolveImageInfo2KHR*)(pResolveImageInfo), readStreamPtrPtr);
2014 if (pResolveImageInfo)
2015 {
2016 transform_tohost_VkResolveImageInfo2KHR(globalstate, (VkResolveImageInfo2KHR*)(pResolveImageInfo));
2017 }
2018 vk->vkCmdResolveImage2KHR((VkCommandBuffer)dispatchHandle, pResolveImageInfo);
2019 android::base::endTrace();
2020 break;
2021 }
2022 #endif
2023 #ifdef VK_ANDROID_native_buffer
2024 #endif
2025 #ifdef VK_EXT_debug_report
2026 #endif
2027 #ifdef VK_NV_glsl_shader
2028 #endif
2029 #ifdef VK_EXT_depth_range_unrestricted
2030 #endif
2031 #ifdef VK_IMG_filter_cubic
2032 #endif
2033 #ifdef VK_AMD_rasterization_order
2034 #endif
2035 #ifdef VK_AMD_shader_trinary_minmax
2036 #endif
2037 #ifdef VK_AMD_shader_explicit_vertex_parameter
2038 #endif
2039 #ifdef VK_EXT_debug_marker
2040 case OP_vkCmdDebugMarkerBeginEXT:
2041 {
2042 android::base::beginTrace("vkCmdDebugMarkerBeginEXT subdecode");
2043 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo;
2044 VkDebugMarkerMarkerInfoEXT stack_pMarkerInfo[1];
2045 pMarkerInfo = (VkDebugMarkerMarkerInfoEXT*)stack_pMarkerInfo;
2046 reservedunmarshal_VkDebugMarkerMarkerInfoEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugMarkerMarkerInfoEXT*)(pMarkerInfo), readStreamPtrPtr);
2047 if (pMarkerInfo)
2048 {
2049 transform_tohost_VkDebugMarkerMarkerInfoEXT(globalstate, (VkDebugMarkerMarkerInfoEXT*)(pMarkerInfo));
2050 }
2051 vk->vkCmdDebugMarkerBeginEXT((VkCommandBuffer)dispatchHandle, pMarkerInfo);
2052 android::base::endTrace();
2053 break;
2054 }
2055 case OP_vkCmdDebugMarkerEndEXT:
2056 {
2057 android::base::beginTrace("vkCmdDebugMarkerEndEXT subdecode");
2058 vk->vkCmdDebugMarkerEndEXT((VkCommandBuffer)dispatchHandle);
2059 android::base::endTrace();
2060 break;
2061 }
2062 case OP_vkCmdDebugMarkerInsertEXT:
2063 {
2064 android::base::beginTrace("vkCmdDebugMarkerInsertEXT subdecode");
2065 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo;
2066 VkDebugMarkerMarkerInfoEXT stack_pMarkerInfo[1];
2067 pMarkerInfo = (VkDebugMarkerMarkerInfoEXT*)stack_pMarkerInfo;
2068 reservedunmarshal_VkDebugMarkerMarkerInfoEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugMarkerMarkerInfoEXT*)(pMarkerInfo), readStreamPtrPtr);
2069 if (pMarkerInfo)
2070 {
2071 transform_tohost_VkDebugMarkerMarkerInfoEXT(globalstate, (VkDebugMarkerMarkerInfoEXT*)(pMarkerInfo));
2072 }
2073 vk->vkCmdDebugMarkerInsertEXT((VkCommandBuffer)dispatchHandle, pMarkerInfo);
2074 android::base::endTrace();
2075 break;
2076 }
2077 #endif
2078 #ifdef VK_AMD_gcn_shader
2079 #endif
2080 #ifdef VK_NV_dedicated_allocation
2081 #endif
2082 #ifdef VK_EXT_transform_feedback
2083 case OP_vkCmdBindTransformFeedbackBuffersEXT:
2084 {
2085 android::base::beginTrace("vkCmdBindTransformFeedbackBuffersEXT subdecode");
2086 uint32_t firstBinding;
2087 uint32_t bindingCount;
2088 const VkBuffer* pBuffers;
2089 VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
2090 const VkDeviceSize* pOffsets;
2091 VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
2092 const VkDeviceSize* pSizes;
2093 VkDeviceSize stack_pSizes[MAX_STACK_ITEMS];
2094 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
2095 *readStreamPtrPtr += sizeof(uint32_t);
2096 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
2097 *readStreamPtrPtr += sizeof(uint32_t);
2098 if (((bindingCount)) <= MAX_STACK_ITEMS)
2099 {
2100 pBuffers = (VkBuffer*)stack_pBuffers;
2101 }
2102 else
2103 {
2104 readStream->alloc((void**)&pBuffers, ((bindingCount)) * sizeof(const VkBuffer));
2105 }
2106 if (((bindingCount)))
2107 {
2108 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2109 *readStreamPtrPtr += 8 * ((bindingCount));
2110 for (uint32_t k = 0; k < ((bindingCount)); ++k)
2111 {
2112 uint64_t tmpval; memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
2113 *(((VkBuffer*)pBuffers) + k) = (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval);
2114 }
2115 }
2116 if (((bindingCount)) <= MAX_STACK_ITEMS)
2117 {
2118 pOffsets = (VkDeviceSize*)stack_pOffsets;
2119 }
2120 else
2121 {
2122 readStream->alloc((void**)&pOffsets, ((bindingCount)) * sizeof(const VkDeviceSize));
2123 }
2124 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr, ((bindingCount)) * sizeof(const VkDeviceSize));
2125 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
2126 // WARNING PTR CHECK
2127 memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
2128 android::base::Stream::fromBe64((uint8_t*)&pSizes);
2129 *readStreamPtrPtr += 8;
2130 if (pSizes)
2131 {
2132 if (((bindingCount)) <= MAX_STACK_ITEMS)
2133 {
2134 pSizes = (VkDeviceSize*)stack_pSizes;
2135 }
2136 else
2137 {
2138 readStream->alloc((void**)&pSizes, ((bindingCount)) * sizeof(const VkDeviceSize));
2139 }
2140 memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr, ((bindingCount)) * sizeof(const VkDeviceSize));
2141 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
2142 }
2143 vk->vkCmdBindTransformFeedbackBuffersEXT((VkCommandBuffer)dispatchHandle, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
2144 android::base::endTrace();
2145 break;
2146 }
2147 case OP_vkCmdBeginTransformFeedbackEXT:
2148 {
2149 android::base::beginTrace("vkCmdBeginTransformFeedbackEXT subdecode");
2150 uint32_t firstCounterBuffer;
2151 uint32_t counterBufferCount;
2152 const VkBuffer* pCounterBuffers;
2153 VkBuffer stack_pCounterBuffers[MAX_STACK_ITEMS];
2154 const VkDeviceSize* pCounterBufferOffsets;
2155 VkDeviceSize stack_pCounterBufferOffsets[MAX_STACK_ITEMS];
2156 memcpy((uint32_t*)&firstCounterBuffer, *readStreamPtrPtr, sizeof(uint32_t));
2157 *readStreamPtrPtr += sizeof(uint32_t);
2158 memcpy((uint32_t*)&counterBufferCount, *readStreamPtrPtr, sizeof(uint32_t));
2159 *readStreamPtrPtr += sizeof(uint32_t);
2160 // WARNING PTR CHECK
2161 memcpy((VkBuffer**)&pCounterBuffers, (*readStreamPtrPtr), 8);
2162 android::base::Stream::fromBe64((uint8_t*)&pCounterBuffers);
2163 *readStreamPtrPtr += 8;
2164 if (pCounterBuffers)
2165 {
2166 if (((counterBufferCount)) <= MAX_STACK_ITEMS)
2167 {
2168 pCounterBuffers = (VkBuffer*)stack_pCounterBuffers;
2169 }
2170 else
2171 {
2172 readStream->alloc((void**)&pCounterBuffers, ((counterBufferCount)) * sizeof(const VkBuffer));
2173 }
2174 if (((counterBufferCount)))
2175 {
2176 uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2177 *readStreamPtrPtr += 8 * ((counterBufferCount));
2178 for (uint32_t k = 0; k < ((counterBufferCount)); ++k)
2179 {
2180 uint64_t tmpval; memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
2181 *(((VkBuffer*)pCounterBuffers) + k) = (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval);
2182 }
2183 }
2184 }
2185 // WARNING PTR CHECK
2186 memcpy((VkDeviceSize**)&pCounterBufferOffsets, (*readStreamPtrPtr), 8);
2187 android::base::Stream::fromBe64((uint8_t*)&pCounterBufferOffsets);
2188 *readStreamPtrPtr += 8;
2189 if (pCounterBufferOffsets)
2190 {
2191 if (((counterBufferCount)) <= MAX_STACK_ITEMS)
2192 {
2193 pCounterBufferOffsets = (VkDeviceSize*)stack_pCounterBufferOffsets;
2194 }
2195 else
2196 {
2197 readStream->alloc((void**)&pCounterBufferOffsets, ((counterBufferCount)) * sizeof(const VkDeviceSize));
2198 }
2199 memcpy((VkDeviceSize*)pCounterBufferOffsets, *readStreamPtrPtr, ((counterBufferCount)) * sizeof(const VkDeviceSize));
2200 *readStreamPtrPtr += ((counterBufferCount)) * sizeof(const VkDeviceSize);
2201 }
2202 vk->vkCmdBeginTransformFeedbackEXT((VkCommandBuffer)dispatchHandle, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
2203 android::base::endTrace();
2204 break;
2205 }
2206 case OP_vkCmdEndTransformFeedbackEXT:
2207 {
2208 android::base::beginTrace("vkCmdEndTransformFeedbackEXT subdecode");
2209 uint32_t firstCounterBuffer;
2210 uint32_t counterBufferCount;
2211 const VkBuffer* pCounterBuffers;
2212 VkBuffer stack_pCounterBuffers[MAX_STACK_ITEMS];
2213 const VkDeviceSize* pCounterBufferOffsets;
2214 VkDeviceSize stack_pCounterBufferOffsets[MAX_STACK_ITEMS];
2215 memcpy((uint32_t*)&firstCounterBuffer, *readStreamPtrPtr, sizeof(uint32_t));
2216 *readStreamPtrPtr += sizeof(uint32_t);
2217 memcpy((uint32_t*)&counterBufferCount, *readStreamPtrPtr, sizeof(uint32_t));
2218 *readStreamPtrPtr += sizeof(uint32_t);
2219 // WARNING PTR CHECK
2220 memcpy((VkBuffer**)&pCounterBuffers, (*readStreamPtrPtr), 8);
2221 android::base::Stream::fromBe64((uint8_t*)&pCounterBuffers);
2222 *readStreamPtrPtr += 8;
2223 if (pCounterBuffers)
2224 {
2225 if (((counterBufferCount)) <= MAX_STACK_ITEMS)
2226 {
2227 pCounterBuffers = (VkBuffer*)stack_pCounterBuffers;
2228 }
2229 else
2230 {
2231 readStream->alloc((void**)&pCounterBuffers, ((counterBufferCount)) * sizeof(const VkBuffer));
2232 }
2233 if (((counterBufferCount)))
2234 {
2235 uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2236 *readStreamPtrPtr += 8 * ((counterBufferCount));
2237 for (uint32_t k = 0; k < ((counterBufferCount)); ++k)
2238 {
2239 uint64_t tmpval; memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
2240 *(((VkBuffer*)pCounterBuffers) + k) = (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval);
2241 }
2242 }
2243 }
2244 // WARNING PTR CHECK
2245 memcpy((VkDeviceSize**)&pCounterBufferOffsets, (*readStreamPtrPtr), 8);
2246 android::base::Stream::fromBe64((uint8_t*)&pCounterBufferOffsets);
2247 *readStreamPtrPtr += 8;
2248 if (pCounterBufferOffsets)
2249 {
2250 if (((counterBufferCount)) <= MAX_STACK_ITEMS)
2251 {
2252 pCounterBufferOffsets = (VkDeviceSize*)stack_pCounterBufferOffsets;
2253 }
2254 else
2255 {
2256 readStream->alloc((void**)&pCounterBufferOffsets, ((counterBufferCount)) * sizeof(const VkDeviceSize));
2257 }
2258 memcpy((VkDeviceSize*)pCounterBufferOffsets, *readStreamPtrPtr, ((counterBufferCount)) * sizeof(const VkDeviceSize));
2259 *readStreamPtrPtr += ((counterBufferCount)) * sizeof(const VkDeviceSize);
2260 }
2261 vk->vkCmdEndTransformFeedbackEXT((VkCommandBuffer)dispatchHandle, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
2262 android::base::endTrace();
2263 break;
2264 }
2265 case OP_vkCmdBeginQueryIndexedEXT:
2266 {
2267 android::base::beginTrace("vkCmdBeginQueryIndexedEXT subdecode");
2268 VkQueryPool queryPool;
2269 uint32_t query;
2270 VkQueryControlFlags flags;
2271 uint32_t index;
2272 uint64_t cgen_var_0;
2273 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2274 *readStreamPtrPtr += 1 * 8;
2275 *(VkQueryPool*)&queryPool = (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
2276 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
2277 *readStreamPtrPtr += sizeof(uint32_t);
2278 memcpy((VkQueryControlFlags*)&flags, *readStreamPtrPtr, sizeof(VkQueryControlFlags));
2279 *readStreamPtrPtr += sizeof(VkQueryControlFlags);
2280 memcpy((uint32_t*)&index, *readStreamPtrPtr, sizeof(uint32_t));
2281 *readStreamPtrPtr += sizeof(uint32_t);
2282 vk->vkCmdBeginQueryIndexedEXT((VkCommandBuffer)dispatchHandle, queryPool, query, flags, index);
2283 android::base::endTrace();
2284 break;
2285 }
2286 case OP_vkCmdEndQueryIndexedEXT:
2287 {
2288 android::base::beginTrace("vkCmdEndQueryIndexedEXT subdecode");
2289 VkQueryPool queryPool;
2290 uint32_t query;
2291 uint32_t index;
2292 uint64_t cgen_var_0;
2293 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2294 *readStreamPtrPtr += 1 * 8;
2295 *(VkQueryPool*)&queryPool = (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
2296 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
2297 *readStreamPtrPtr += sizeof(uint32_t);
2298 memcpy((uint32_t*)&index, *readStreamPtrPtr, sizeof(uint32_t));
2299 *readStreamPtrPtr += sizeof(uint32_t);
2300 vk->vkCmdEndQueryIndexedEXT((VkCommandBuffer)dispatchHandle, queryPool, query, index);
2301 android::base::endTrace();
2302 break;
2303 }
2304 case OP_vkCmdDrawIndirectByteCountEXT:
2305 {
2306 android::base::beginTrace("vkCmdDrawIndirectByteCountEXT subdecode");
2307 uint32_t instanceCount;
2308 uint32_t firstInstance;
2309 VkBuffer counterBuffer;
2310 VkDeviceSize counterBufferOffset;
2311 uint32_t counterOffset;
2312 uint32_t vertexStride;
2313 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
2314 *readStreamPtrPtr += sizeof(uint32_t);
2315 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
2316 *readStreamPtrPtr += sizeof(uint32_t);
2317 uint64_t cgen_var_0;
2318 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2319 *readStreamPtrPtr += 1 * 8;
2320 *(VkBuffer*)&counterBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
2321 memcpy((VkDeviceSize*)&counterBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2322 *readStreamPtrPtr += sizeof(VkDeviceSize);
2323 memcpy((uint32_t*)&counterOffset, *readStreamPtrPtr, sizeof(uint32_t));
2324 *readStreamPtrPtr += sizeof(uint32_t);
2325 memcpy((uint32_t*)&vertexStride, *readStreamPtrPtr, sizeof(uint32_t));
2326 *readStreamPtrPtr += sizeof(uint32_t);
2327 vk->vkCmdDrawIndirectByteCountEXT((VkCommandBuffer)dispatchHandle, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
2328 android::base::endTrace();
2329 break;
2330 }
2331 #endif
2332 #ifdef VK_NVX_image_view_handle
2333 #endif
2334 #ifdef VK_AMD_draw_indirect_count
2335 case OP_vkCmdDrawIndirectCountAMD:
2336 {
2337 android::base::beginTrace("vkCmdDrawIndirectCountAMD subdecode");
2338 VkBuffer buffer;
2339 VkDeviceSize offset;
2340 VkBuffer countBuffer;
2341 VkDeviceSize countBufferOffset;
2342 uint32_t maxDrawCount;
2343 uint32_t stride;
2344 uint64_t cgen_var_0;
2345 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2346 *readStreamPtrPtr += 1 * 8;
2347 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
2348 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2349 *readStreamPtrPtr += sizeof(VkDeviceSize);
2350 uint64_t cgen_var_1;
2351 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2352 *readStreamPtrPtr += 1 * 8;
2353 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
2354 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2355 *readStreamPtrPtr += sizeof(VkDeviceSize);
2356 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
2357 *readStreamPtrPtr += sizeof(uint32_t);
2358 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
2359 *readStreamPtrPtr += sizeof(uint32_t);
2360 vk->vkCmdDrawIndirectCountAMD((VkCommandBuffer)dispatchHandle, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
2361 android::base::endTrace();
2362 break;
2363 }
2364 case OP_vkCmdDrawIndexedIndirectCountAMD:
2365 {
2366 android::base::beginTrace("vkCmdDrawIndexedIndirectCountAMD subdecode");
2367 VkBuffer buffer;
2368 VkDeviceSize offset;
2369 VkBuffer countBuffer;
2370 VkDeviceSize countBufferOffset;
2371 uint32_t maxDrawCount;
2372 uint32_t stride;
2373 uint64_t cgen_var_0;
2374 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2375 *readStreamPtrPtr += 1 * 8;
2376 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
2377 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2378 *readStreamPtrPtr += sizeof(VkDeviceSize);
2379 uint64_t cgen_var_1;
2380 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2381 *readStreamPtrPtr += 1 * 8;
2382 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
2383 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2384 *readStreamPtrPtr += sizeof(VkDeviceSize);
2385 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
2386 *readStreamPtrPtr += sizeof(uint32_t);
2387 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
2388 *readStreamPtrPtr += sizeof(uint32_t);
2389 vk->vkCmdDrawIndexedIndirectCountAMD((VkCommandBuffer)dispatchHandle, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
2390 android::base::endTrace();
2391 break;
2392 }
2393 #endif
2394 #ifdef VK_AMD_negative_viewport_height
2395 #endif
2396 #ifdef VK_AMD_gpu_shader_half_float
2397 #endif
2398 #ifdef VK_AMD_shader_ballot
2399 #endif
2400 #ifdef VK_AMD_texture_gather_bias_lod
2401 #endif
2402 #ifdef VK_AMD_shader_info
2403 #endif
2404 #ifdef VK_AMD_shader_image_load_store_lod
2405 #endif
2406 #ifdef VK_GGP_stream_descriptor_surface
2407 #endif
2408 #ifdef VK_NV_corner_sampled_image
2409 #endif
2410 #ifdef VK_IMG_format_pvrtc
2411 #endif
2412 #ifdef VK_NV_external_memory_capabilities
2413 #endif
2414 #ifdef VK_NV_external_memory
2415 #endif
2416 #ifdef VK_NV_external_memory_win32
2417 #endif
2418 #ifdef VK_NV_win32_keyed_mutex
2419 #endif
2420 #ifdef VK_EXT_validation_flags
2421 #endif
2422 #ifdef VK_NN_vi_surface
2423 #endif
2424 #ifdef VK_EXT_shader_subgroup_ballot
2425 #endif
2426 #ifdef VK_EXT_shader_subgroup_vote
2427 #endif
2428 #ifdef VK_EXT_texture_compression_astc_hdr
2429 #endif
2430 #ifdef VK_EXT_astc_decode_mode
2431 #endif
2432 #ifdef VK_EXT_conditional_rendering
2433 case OP_vkCmdBeginConditionalRenderingEXT:
2434 {
2435 android::base::beginTrace("vkCmdBeginConditionalRenderingEXT subdecode");
2436 const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin;
2437 VkConditionalRenderingBeginInfoEXT stack_pConditionalRenderingBegin[1];
2438 pConditionalRenderingBegin = (VkConditionalRenderingBeginInfoEXT*)stack_pConditionalRenderingBegin;
2439 reservedunmarshal_VkConditionalRenderingBeginInfoEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkConditionalRenderingBeginInfoEXT*)(pConditionalRenderingBegin), readStreamPtrPtr);
2440 if (pConditionalRenderingBegin)
2441 {
2442 transform_tohost_VkConditionalRenderingBeginInfoEXT(globalstate, (VkConditionalRenderingBeginInfoEXT*)(pConditionalRenderingBegin));
2443 }
2444 vk->vkCmdBeginConditionalRenderingEXT((VkCommandBuffer)dispatchHandle, pConditionalRenderingBegin);
2445 android::base::endTrace();
2446 break;
2447 }
2448 case OP_vkCmdEndConditionalRenderingEXT:
2449 {
2450 android::base::beginTrace("vkCmdEndConditionalRenderingEXT subdecode");
2451 vk->vkCmdEndConditionalRenderingEXT((VkCommandBuffer)dispatchHandle);
2452 android::base::endTrace();
2453 break;
2454 }
2455 #endif
2456 #ifdef VK_NV_clip_space_w_scaling
2457 case OP_vkCmdSetViewportWScalingNV:
2458 {
2459 android::base::beginTrace("vkCmdSetViewportWScalingNV subdecode");
2460 uint32_t firstViewport;
2461 uint32_t viewportCount;
2462 const VkViewportWScalingNV* pViewportWScalings;
2463 VkViewportWScalingNV stack_pViewportWScalings[MAX_STACK_ITEMS];
2464 memcpy((uint32_t*)&firstViewport, *readStreamPtrPtr, sizeof(uint32_t));
2465 *readStreamPtrPtr += sizeof(uint32_t);
2466 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
2467 *readStreamPtrPtr += sizeof(uint32_t);
2468 if (((viewportCount)) <= MAX_STACK_ITEMS)
2469 {
2470 pViewportWScalings = (VkViewportWScalingNV*)stack_pViewportWScalings;
2471 }
2472 else
2473 {
2474 readStream->alloc((void**)&pViewportWScalings, ((viewportCount)) * sizeof(const VkViewportWScalingNV));
2475 }
2476 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
2477 {
2478 reservedunmarshal_VkViewportWScalingNV(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViewportWScalingNV*)(pViewportWScalings + i), readStreamPtrPtr);
2479 }
2480 if (pViewportWScalings)
2481 {
2482 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
2483 {
2484 transform_tohost_VkViewportWScalingNV(globalstate, (VkViewportWScalingNV*)(pViewportWScalings + i));
2485 }
2486 }
2487 vk->vkCmdSetViewportWScalingNV((VkCommandBuffer)dispatchHandle, firstViewport, viewportCount, pViewportWScalings);
2488 android::base::endTrace();
2489 break;
2490 }
2491 #endif
2492 #ifdef VK_EXT_direct_mode_display
2493 #endif
2494 #ifdef VK_EXT_acquire_xlib_display
2495 #endif
2496 #ifdef VK_EXT_display_surface_counter
2497 #endif
2498 #ifdef VK_EXT_display_control
2499 #endif
2500 #ifdef VK_GOOGLE_display_timing
2501 #endif
2502 #ifdef VK_NV_sample_mask_override_coverage
2503 #endif
2504 #ifdef VK_NV_geometry_shader_passthrough
2505 #endif
2506 #ifdef VK_NV_viewport_array2
2507 #endif
2508 #ifdef VK_NVX_multiview_per_view_attributes
2509 #endif
2510 #ifdef VK_NV_viewport_swizzle
2511 #endif
2512 #ifdef VK_EXT_discard_rectangles
2513 case OP_vkCmdSetDiscardRectangleEXT:
2514 {
2515 android::base::beginTrace("vkCmdSetDiscardRectangleEXT subdecode");
2516 uint32_t firstDiscardRectangle;
2517 uint32_t discardRectangleCount;
2518 const VkRect2D* pDiscardRectangles;
2519 VkRect2D stack_pDiscardRectangles[MAX_STACK_ITEMS];
2520 memcpy((uint32_t*)&firstDiscardRectangle, *readStreamPtrPtr, sizeof(uint32_t));
2521 *readStreamPtrPtr += sizeof(uint32_t);
2522 memcpy((uint32_t*)&discardRectangleCount, *readStreamPtrPtr, sizeof(uint32_t));
2523 *readStreamPtrPtr += sizeof(uint32_t);
2524 if (((discardRectangleCount)) <= MAX_STACK_ITEMS)
2525 {
2526 pDiscardRectangles = (VkRect2D*)stack_pDiscardRectangles;
2527 }
2528 else
2529 {
2530 readStream->alloc((void**)&pDiscardRectangles, ((discardRectangleCount)) * sizeof(const VkRect2D));
2531 }
2532 for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
2533 {
2534 reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(pDiscardRectangles + i), readStreamPtrPtr);
2535 }
2536 if (pDiscardRectangles)
2537 {
2538 for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
2539 {
2540 transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pDiscardRectangles + i));
2541 }
2542 }
2543 vk->vkCmdSetDiscardRectangleEXT((VkCommandBuffer)dispatchHandle, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
2544 android::base::endTrace();
2545 break;
2546 }
2547 #endif
2548 #ifdef VK_EXT_conservative_rasterization
2549 #endif
2550 #ifdef VK_EXT_depth_clip_enable
2551 #endif
2552 #ifdef VK_EXT_swapchain_colorspace
2553 #endif
2554 #ifdef VK_EXT_hdr_metadata
2555 #endif
2556 #ifdef VK_MVK_ios_surface
2557 #endif
2558 #ifdef VK_MVK_macos_surface
2559 #endif
2560 #ifdef VK_MVK_moltenvk
2561 #endif
2562 #ifdef VK_EXT_external_memory_dma_buf
2563 #endif
2564 #ifdef VK_EXT_queue_family_foreign
2565 #endif
2566 #ifdef VK_EXT_debug_utils
2567 case OP_vkCmdBeginDebugUtilsLabelEXT:
2568 {
2569 android::base::beginTrace("vkCmdBeginDebugUtilsLabelEXT subdecode");
2570 const VkDebugUtilsLabelEXT* pLabelInfo;
2571 VkDebugUtilsLabelEXT stack_pLabelInfo[1];
2572 pLabelInfo = (VkDebugUtilsLabelEXT*)stack_pLabelInfo;
2573 reservedunmarshal_VkDebugUtilsLabelEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsLabelEXT*)(pLabelInfo), readStreamPtrPtr);
2574 if (pLabelInfo)
2575 {
2576 transform_tohost_VkDebugUtilsLabelEXT(globalstate, (VkDebugUtilsLabelEXT*)(pLabelInfo));
2577 }
2578 vk->vkCmdBeginDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle, pLabelInfo);
2579 android::base::endTrace();
2580 break;
2581 }
2582 case OP_vkCmdEndDebugUtilsLabelEXT:
2583 {
2584 android::base::beginTrace("vkCmdEndDebugUtilsLabelEXT subdecode");
2585 vk->vkCmdEndDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle);
2586 android::base::endTrace();
2587 break;
2588 }
2589 case OP_vkCmdInsertDebugUtilsLabelEXT:
2590 {
2591 android::base::beginTrace("vkCmdInsertDebugUtilsLabelEXT subdecode");
2592 const VkDebugUtilsLabelEXT* pLabelInfo;
2593 VkDebugUtilsLabelEXT stack_pLabelInfo[1];
2594 pLabelInfo = (VkDebugUtilsLabelEXT*)stack_pLabelInfo;
2595 reservedunmarshal_VkDebugUtilsLabelEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsLabelEXT*)(pLabelInfo), readStreamPtrPtr);
2596 if (pLabelInfo)
2597 {
2598 transform_tohost_VkDebugUtilsLabelEXT(globalstate, (VkDebugUtilsLabelEXT*)(pLabelInfo));
2599 }
2600 vk->vkCmdInsertDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle, pLabelInfo);
2601 android::base::endTrace();
2602 break;
2603 }
2604 #endif
2605 #ifdef VK_ANDROID_external_memory_android_hardware_buffer
2606 #endif
2607 #ifdef VK_EXT_sampler_filter_minmax
2608 #endif
2609 #ifdef VK_AMD_gpu_shader_int16
2610 #endif
2611 #ifdef VK_AMD_mixed_attachment_samples
2612 #endif
2613 #ifdef VK_AMD_shader_fragment_mask
2614 #endif
2615 #ifdef VK_EXT_inline_uniform_block
2616 #endif
2617 #ifdef VK_EXT_shader_stencil_export
2618 #endif
2619 #ifdef VK_EXT_sample_locations
2620 case OP_vkCmdSetSampleLocationsEXT:
2621 {
2622 android::base::beginTrace("vkCmdSetSampleLocationsEXT subdecode");
2623 const VkSampleLocationsInfoEXT* pSampleLocationsInfo;
2624 VkSampleLocationsInfoEXT stack_pSampleLocationsInfo[1];
2625 pSampleLocationsInfo = (VkSampleLocationsInfoEXT*)stack_pSampleLocationsInfo;
2626 reservedunmarshal_VkSampleLocationsInfoEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSampleLocationsInfoEXT*)(pSampleLocationsInfo), readStreamPtrPtr);
2627 if (pSampleLocationsInfo)
2628 {
2629 transform_tohost_VkSampleLocationsInfoEXT(globalstate, (VkSampleLocationsInfoEXT*)(pSampleLocationsInfo));
2630 }
2631 vk->vkCmdSetSampleLocationsEXT((VkCommandBuffer)dispatchHandle, pSampleLocationsInfo);
2632 android::base::endTrace();
2633 break;
2634 }
2635 #endif
2636 #ifdef VK_EXT_blend_operation_advanced
2637 #endif
2638 #ifdef VK_NV_fragment_coverage_to_color
2639 #endif
2640 #ifdef VK_NV_framebuffer_mixed_samples
2641 #endif
2642 #ifdef VK_NV_fill_rectangle
2643 #endif
2644 #ifdef VK_NV_shader_sm_builtins
2645 #endif
2646 #ifdef VK_EXT_post_depth_coverage
2647 #endif
2648 #ifdef VK_EXT_image_drm_format_modifier
2649 #endif
2650 #ifdef VK_EXT_validation_cache
2651 #endif
2652 #ifdef VK_EXT_descriptor_indexing
2653 #endif
2654 #ifdef VK_EXT_shader_viewport_index_layer
2655 #endif
2656 #ifdef VK_NV_shading_rate_image
2657 case OP_vkCmdBindShadingRateImageNV:
2658 {
2659 android::base::beginTrace("vkCmdBindShadingRateImageNV subdecode");
2660 VkImageView imageView;
2661 VkImageLayout imageLayout;
2662 uint64_t cgen_var_0;
2663 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2664 *readStreamPtrPtr += 1 * 8;
2665 *(VkImageView*)&imageView = (VkImageView)unbox_VkImageView((VkImageView)(*&cgen_var_0));
2666 memcpy((VkImageLayout*)&imageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
2667 *readStreamPtrPtr += sizeof(VkImageLayout);
2668 vk->vkCmdBindShadingRateImageNV((VkCommandBuffer)dispatchHandle, imageView, imageLayout);
2669 android::base::endTrace();
2670 break;
2671 }
2672 case OP_vkCmdSetViewportShadingRatePaletteNV:
2673 {
2674 android::base::beginTrace("vkCmdSetViewportShadingRatePaletteNV subdecode");
2675 uint32_t firstViewport;
2676 uint32_t viewportCount;
2677 const VkShadingRatePaletteNV* pShadingRatePalettes;
2678 VkShadingRatePaletteNV stack_pShadingRatePalettes[MAX_STACK_ITEMS];
2679 memcpy((uint32_t*)&firstViewport, *readStreamPtrPtr, sizeof(uint32_t));
2680 *readStreamPtrPtr += sizeof(uint32_t);
2681 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
2682 *readStreamPtrPtr += sizeof(uint32_t);
2683 if (((viewportCount)) <= MAX_STACK_ITEMS)
2684 {
2685 pShadingRatePalettes = (VkShadingRatePaletteNV*)stack_pShadingRatePalettes;
2686 }
2687 else
2688 {
2689 readStream->alloc((void**)&pShadingRatePalettes, ((viewportCount)) * sizeof(const VkShadingRatePaletteNV));
2690 }
2691 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
2692 {
2693 reservedunmarshal_VkShadingRatePaletteNV(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkShadingRatePaletteNV*)(pShadingRatePalettes + i), readStreamPtrPtr);
2694 }
2695 if (pShadingRatePalettes)
2696 {
2697 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
2698 {
2699 transform_tohost_VkShadingRatePaletteNV(globalstate, (VkShadingRatePaletteNV*)(pShadingRatePalettes + i));
2700 }
2701 }
2702 vk->vkCmdSetViewportShadingRatePaletteNV((VkCommandBuffer)dispatchHandle, firstViewport, viewportCount, pShadingRatePalettes);
2703 android::base::endTrace();
2704 break;
2705 }
2706 case OP_vkCmdSetCoarseSampleOrderNV:
2707 {
2708 android::base::beginTrace("vkCmdSetCoarseSampleOrderNV subdecode");
2709 VkCoarseSampleOrderTypeNV sampleOrderType;
2710 uint32_t customSampleOrderCount;
2711 const VkCoarseSampleOrderCustomNV* pCustomSampleOrders;
2712 VkCoarseSampleOrderCustomNV stack_pCustomSampleOrders[MAX_STACK_ITEMS];
2713 memcpy((VkCoarseSampleOrderTypeNV*)&sampleOrderType, *readStreamPtrPtr, sizeof(VkCoarseSampleOrderTypeNV));
2714 *readStreamPtrPtr += sizeof(VkCoarseSampleOrderTypeNV);
2715 memcpy((uint32_t*)&customSampleOrderCount, *readStreamPtrPtr, sizeof(uint32_t));
2716 *readStreamPtrPtr += sizeof(uint32_t);
2717 if (((customSampleOrderCount)) <= MAX_STACK_ITEMS)
2718 {
2719 pCustomSampleOrders = (VkCoarseSampleOrderCustomNV*)stack_pCustomSampleOrders;
2720 }
2721 else
2722 {
2723 readStream->alloc((void**)&pCustomSampleOrders, ((customSampleOrderCount)) * sizeof(const VkCoarseSampleOrderCustomNV));
2724 }
2725 for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i)
2726 {
2727 reservedunmarshal_VkCoarseSampleOrderCustomNV(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCoarseSampleOrderCustomNV*)(pCustomSampleOrders + i), readStreamPtrPtr);
2728 }
2729 if (pCustomSampleOrders)
2730 {
2731 for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i)
2732 {
2733 transform_tohost_VkCoarseSampleOrderCustomNV(globalstate, (VkCoarseSampleOrderCustomNV*)(pCustomSampleOrders + i));
2734 }
2735 }
2736 vk->vkCmdSetCoarseSampleOrderNV((VkCommandBuffer)dispatchHandle, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
2737 android::base::endTrace();
2738 break;
2739 }
2740 #endif
2741 #ifdef VK_NV_ray_tracing
2742 case OP_vkCmdBuildAccelerationStructureNV:
2743 {
2744 android::base::beginTrace("vkCmdBuildAccelerationStructureNV subdecode");
2745 const VkAccelerationStructureInfoNV* pInfo;
2746 VkAccelerationStructureInfoNV stack_pInfo[1];
2747 VkBuffer instanceData;
2748 VkDeviceSize instanceOffset;
2749 VkBool32 update;
2750 VkAccelerationStructureNV dst;
2751 VkAccelerationStructureNV src;
2752 VkBuffer scratch;
2753 VkDeviceSize scratchOffset;
2754 pInfo = (VkAccelerationStructureInfoNV*)stack_pInfo;
2755 reservedunmarshal_VkAccelerationStructureInfoNV(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureInfoNV*)(pInfo), readStreamPtrPtr);
2756 uint64_t cgen_var_0;
2757 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2758 *readStreamPtrPtr += 1 * 8;
2759 *(VkBuffer*)&instanceData = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
2760 memcpy((VkDeviceSize*)&instanceOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2761 *readStreamPtrPtr += sizeof(VkDeviceSize);
2762 memcpy((VkBool32*)&update, *readStreamPtrPtr, sizeof(VkBool32));
2763 *readStreamPtrPtr += sizeof(VkBool32);
2764 uint64_t cgen_var_1;
2765 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2766 *readStreamPtrPtr += 1 * 8;
2767 *(VkAccelerationStructureNV*)&dst = (VkAccelerationStructureNV)unbox_VkAccelerationStructureNV((VkAccelerationStructureNV)(*&cgen_var_1));
2768 uint64_t cgen_var_2;
2769 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
2770 *readStreamPtrPtr += 1 * 8;
2771 *(VkAccelerationStructureNV*)&src = (VkAccelerationStructureNV)unbox_VkAccelerationStructureNV((VkAccelerationStructureNV)(*&cgen_var_2));
2772 uint64_t cgen_var_3;
2773 memcpy((uint64_t*)&cgen_var_3, *readStreamPtrPtr, 1 * 8);
2774 *readStreamPtrPtr += 1 * 8;
2775 *(VkBuffer*)&scratch = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_3));
2776 memcpy((VkDeviceSize*)&scratchOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2777 *readStreamPtrPtr += sizeof(VkDeviceSize);
2778 if (pInfo)
2779 {
2780 transform_tohost_VkAccelerationStructureInfoNV(globalstate, (VkAccelerationStructureInfoNV*)(pInfo));
2781 }
2782 vk->vkCmdBuildAccelerationStructureNV((VkCommandBuffer)dispatchHandle, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
2783 android::base::endTrace();
2784 break;
2785 }
2786 case OP_vkCmdCopyAccelerationStructureNV:
2787 {
2788 android::base::beginTrace("vkCmdCopyAccelerationStructureNV subdecode");
2789 VkAccelerationStructureNV dst;
2790 VkAccelerationStructureNV src;
2791 VkCopyAccelerationStructureModeKHR mode;
2792 uint64_t cgen_var_0;
2793 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2794 *readStreamPtrPtr += 1 * 8;
2795 *(VkAccelerationStructureNV*)&dst = (VkAccelerationStructureNV)unbox_VkAccelerationStructureNV((VkAccelerationStructureNV)(*&cgen_var_0));
2796 uint64_t cgen_var_1;
2797 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2798 *readStreamPtrPtr += 1 * 8;
2799 *(VkAccelerationStructureNV*)&src = (VkAccelerationStructureNV)unbox_VkAccelerationStructureNV((VkAccelerationStructureNV)(*&cgen_var_1));
2800 memcpy((VkCopyAccelerationStructureModeKHR*)&mode, *readStreamPtrPtr, sizeof(VkCopyAccelerationStructureModeKHR));
2801 *readStreamPtrPtr += sizeof(VkCopyAccelerationStructureModeKHR);
2802 vk->vkCmdCopyAccelerationStructureNV((VkCommandBuffer)dispatchHandle, dst, src, mode);
2803 android::base::endTrace();
2804 break;
2805 }
2806 case OP_vkCmdTraceRaysNV:
2807 {
2808 android::base::beginTrace("vkCmdTraceRaysNV subdecode");
2809 VkBuffer raygenShaderBindingTableBuffer;
2810 VkDeviceSize raygenShaderBindingOffset;
2811 VkBuffer missShaderBindingTableBuffer;
2812 VkDeviceSize missShaderBindingOffset;
2813 VkDeviceSize missShaderBindingStride;
2814 VkBuffer hitShaderBindingTableBuffer;
2815 VkDeviceSize hitShaderBindingOffset;
2816 VkDeviceSize hitShaderBindingStride;
2817 VkBuffer callableShaderBindingTableBuffer;
2818 VkDeviceSize callableShaderBindingOffset;
2819 VkDeviceSize callableShaderBindingStride;
2820 uint32_t width;
2821 uint32_t height;
2822 uint32_t depth;
2823 uint64_t cgen_var_0;
2824 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2825 *readStreamPtrPtr += 1 * 8;
2826 *(VkBuffer*)&raygenShaderBindingTableBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
2827 memcpy((VkDeviceSize*)&raygenShaderBindingOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2828 *readStreamPtrPtr += sizeof(VkDeviceSize);
2829 uint64_t cgen_var_1;
2830 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2831 *readStreamPtrPtr += 1 * 8;
2832 *(VkBuffer*)&missShaderBindingTableBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
2833 memcpy((VkDeviceSize*)&missShaderBindingOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2834 *readStreamPtrPtr += sizeof(VkDeviceSize);
2835 memcpy((VkDeviceSize*)&missShaderBindingStride, *readStreamPtrPtr, sizeof(VkDeviceSize));
2836 *readStreamPtrPtr += sizeof(VkDeviceSize);
2837 uint64_t cgen_var_2;
2838 memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
2839 *readStreamPtrPtr += 1 * 8;
2840 *(VkBuffer*)&hitShaderBindingTableBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_2));
2841 memcpy((VkDeviceSize*)&hitShaderBindingOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2842 *readStreamPtrPtr += sizeof(VkDeviceSize);
2843 memcpy((VkDeviceSize*)&hitShaderBindingStride, *readStreamPtrPtr, sizeof(VkDeviceSize));
2844 *readStreamPtrPtr += sizeof(VkDeviceSize);
2845 uint64_t cgen_var_3;
2846 memcpy((uint64_t*)&cgen_var_3, *readStreamPtrPtr, 1 * 8);
2847 *readStreamPtrPtr += 1 * 8;
2848 *(VkBuffer*)&callableShaderBindingTableBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_3));
2849 memcpy((VkDeviceSize*)&callableShaderBindingOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2850 *readStreamPtrPtr += sizeof(VkDeviceSize);
2851 memcpy((VkDeviceSize*)&callableShaderBindingStride, *readStreamPtrPtr, sizeof(VkDeviceSize));
2852 *readStreamPtrPtr += sizeof(VkDeviceSize);
2853 memcpy((uint32_t*)&width, *readStreamPtrPtr, sizeof(uint32_t));
2854 *readStreamPtrPtr += sizeof(uint32_t);
2855 memcpy((uint32_t*)&height, *readStreamPtrPtr, sizeof(uint32_t));
2856 *readStreamPtrPtr += sizeof(uint32_t);
2857 memcpy((uint32_t*)&depth, *readStreamPtrPtr, sizeof(uint32_t));
2858 *readStreamPtrPtr += sizeof(uint32_t);
2859 vk->vkCmdTraceRaysNV((VkCommandBuffer)dispatchHandle, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
2860 android::base::endTrace();
2861 break;
2862 }
2863 case OP_vkCmdWriteAccelerationStructuresPropertiesNV:
2864 {
2865 android::base::beginTrace("vkCmdWriteAccelerationStructuresPropertiesNV subdecode");
2866 uint32_t accelerationStructureCount;
2867 const VkAccelerationStructureNV* pAccelerationStructures;
2868 VkAccelerationStructureNV stack_pAccelerationStructures[MAX_STACK_ITEMS];
2869 VkQueryType queryType;
2870 VkQueryPool queryPool;
2871 uint32_t firstQuery;
2872 memcpy((uint32_t*)&accelerationStructureCount, *readStreamPtrPtr, sizeof(uint32_t));
2873 *readStreamPtrPtr += sizeof(uint32_t);
2874 if (((accelerationStructureCount)) <= MAX_STACK_ITEMS)
2875 {
2876 pAccelerationStructures = (VkAccelerationStructureNV*)stack_pAccelerationStructures;
2877 }
2878 else
2879 {
2880 readStream->alloc((void**)&pAccelerationStructures, ((accelerationStructureCount)) * sizeof(const VkAccelerationStructureNV));
2881 }
2882 if (((accelerationStructureCount)))
2883 {
2884 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2885 *readStreamPtrPtr += 8 * ((accelerationStructureCount));
2886 for (uint32_t k = 0; k < ((accelerationStructureCount)); ++k)
2887 {
2888 uint64_t tmpval; memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
2889 *(((VkAccelerationStructureNV*)pAccelerationStructures) + k) = (VkAccelerationStructureNV)unbox_VkAccelerationStructureNV((VkAccelerationStructureNV)tmpval);
2890 }
2891 }
2892 memcpy((VkQueryType*)&queryType, *readStreamPtrPtr, sizeof(VkQueryType));
2893 *readStreamPtrPtr += sizeof(VkQueryType);
2894 uint64_t cgen_var_1;
2895 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
2896 *readStreamPtrPtr += 1 * 8;
2897 *(VkQueryPool*)&queryPool = (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
2898 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
2899 *readStreamPtrPtr += sizeof(uint32_t);
2900 vk->vkCmdWriteAccelerationStructuresPropertiesNV((VkCommandBuffer)dispatchHandle, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
2901 android::base::endTrace();
2902 break;
2903 }
2904 #endif
2905 #ifdef VK_NV_representative_fragment_test
2906 #endif
2907 #ifdef VK_EXT_filter_cubic
2908 #endif
2909 #ifdef VK_QCOM_render_pass_shader_resolve
2910 #endif
2911 #ifdef VK_EXT_global_priority
2912 #endif
2913 #ifdef VK_EXT_external_memory_host
2914 #endif
2915 #ifdef VK_AMD_buffer_marker
2916 case OP_vkCmdWriteBufferMarkerAMD:
2917 {
2918 android::base::beginTrace("vkCmdWriteBufferMarkerAMD subdecode");
2919 VkPipelineStageFlagBits pipelineStage;
2920 VkBuffer dstBuffer;
2921 VkDeviceSize dstOffset;
2922 uint32_t marker;
2923 memcpy((VkPipelineStageFlagBits*)&pipelineStage, *readStreamPtrPtr, sizeof(VkPipelineStageFlagBits));
2924 *readStreamPtrPtr += sizeof(VkPipelineStageFlagBits);
2925 uint64_t cgen_var_0;
2926 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2927 *readStreamPtrPtr += 1 * 8;
2928 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
2929 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2930 *readStreamPtrPtr += sizeof(VkDeviceSize);
2931 memcpy((uint32_t*)&marker, *readStreamPtrPtr, sizeof(uint32_t));
2932 *readStreamPtrPtr += sizeof(uint32_t);
2933 vk->vkCmdWriteBufferMarkerAMD((VkCommandBuffer)dispatchHandle, pipelineStage, dstBuffer, dstOffset, marker);
2934 android::base::endTrace();
2935 break;
2936 }
2937 #endif
2938 #ifdef VK_AMD_pipeline_compiler_control
2939 #endif
2940 #ifdef VK_EXT_calibrated_timestamps
2941 #endif
2942 #ifdef VK_AMD_shader_core_properties
2943 #endif
2944 #ifdef VK_AMD_memory_overallocation_behavior
2945 #endif
2946 #ifdef VK_EXT_vertex_attribute_divisor
2947 #endif
2948 #ifdef VK_GGP_frame_token
2949 #endif
2950 #ifdef VK_EXT_pipeline_creation_feedback
2951 #endif
2952 #ifdef VK_NV_shader_subgroup_partitioned
2953 #endif
2954 #ifdef VK_NV_compute_shader_derivatives
2955 #endif
2956 #ifdef VK_NV_mesh_shader
2957 case OP_vkCmdDrawMeshTasksNV:
2958 {
2959 android::base::beginTrace("vkCmdDrawMeshTasksNV subdecode");
2960 uint32_t taskCount;
2961 uint32_t firstTask;
2962 memcpy((uint32_t*)&taskCount, *readStreamPtrPtr, sizeof(uint32_t));
2963 *readStreamPtrPtr += sizeof(uint32_t);
2964 memcpy((uint32_t*)&firstTask, *readStreamPtrPtr, sizeof(uint32_t));
2965 *readStreamPtrPtr += sizeof(uint32_t);
2966 vk->vkCmdDrawMeshTasksNV((VkCommandBuffer)dispatchHandle, taskCount, firstTask);
2967 android::base::endTrace();
2968 break;
2969 }
2970 case OP_vkCmdDrawMeshTasksIndirectNV:
2971 {
2972 android::base::beginTrace("vkCmdDrawMeshTasksIndirectNV subdecode");
2973 VkBuffer buffer;
2974 VkDeviceSize offset;
2975 uint32_t drawCount;
2976 uint32_t stride;
2977 uint64_t cgen_var_0;
2978 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2979 *readStreamPtrPtr += 1 * 8;
2980 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
2981 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2982 *readStreamPtrPtr += sizeof(VkDeviceSize);
2983 memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
2984 *readStreamPtrPtr += sizeof(uint32_t);
2985 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
2986 *readStreamPtrPtr += sizeof(uint32_t);
2987 vk->vkCmdDrawMeshTasksIndirectNV((VkCommandBuffer)dispatchHandle, buffer, offset, drawCount, stride);
2988 android::base::endTrace();
2989 break;
2990 }
2991 case OP_vkCmdDrawMeshTasksIndirectCountNV:
2992 {
2993 android::base::beginTrace("vkCmdDrawMeshTasksIndirectCountNV subdecode");
2994 VkBuffer buffer;
2995 VkDeviceSize offset;
2996 VkBuffer countBuffer;
2997 VkDeviceSize countBufferOffset;
2998 uint32_t maxDrawCount;
2999 uint32_t stride;
3000 uint64_t cgen_var_0;
3001 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3002 *readStreamPtrPtr += 1 * 8;
3003 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
3004 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
3005 *readStreamPtrPtr += sizeof(VkDeviceSize);
3006 uint64_t cgen_var_1;
3007 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3008 *readStreamPtrPtr += 1 * 8;
3009 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
3010 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
3011 *readStreamPtrPtr += sizeof(VkDeviceSize);
3012 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
3013 *readStreamPtrPtr += sizeof(uint32_t);
3014 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
3015 *readStreamPtrPtr += sizeof(uint32_t);
3016 vk->vkCmdDrawMeshTasksIndirectCountNV((VkCommandBuffer)dispatchHandle, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
3017 android::base::endTrace();
3018 break;
3019 }
3020 #endif
3021 #ifdef VK_NV_fragment_shader_barycentric
3022 #endif
3023 #ifdef VK_NV_shader_image_footprint
3024 #endif
3025 #ifdef VK_NV_scissor_exclusive
3026 case OP_vkCmdSetExclusiveScissorNV:
3027 {
3028 android::base::beginTrace("vkCmdSetExclusiveScissorNV subdecode");
3029 uint32_t firstExclusiveScissor;
3030 uint32_t exclusiveScissorCount;
3031 const VkRect2D* pExclusiveScissors;
3032 VkRect2D stack_pExclusiveScissors[MAX_STACK_ITEMS];
3033 memcpy((uint32_t*)&firstExclusiveScissor, *readStreamPtrPtr, sizeof(uint32_t));
3034 *readStreamPtrPtr += sizeof(uint32_t);
3035 memcpy((uint32_t*)&exclusiveScissorCount, *readStreamPtrPtr, sizeof(uint32_t));
3036 *readStreamPtrPtr += sizeof(uint32_t);
3037 if (((exclusiveScissorCount)) <= MAX_STACK_ITEMS)
3038 {
3039 pExclusiveScissors = (VkRect2D*)stack_pExclusiveScissors;
3040 }
3041 else
3042 {
3043 readStream->alloc((void**)&pExclusiveScissors, ((exclusiveScissorCount)) * sizeof(const VkRect2D));
3044 }
3045 for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i)
3046 {
3047 reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(pExclusiveScissors + i), readStreamPtrPtr);
3048 }
3049 if (pExclusiveScissors)
3050 {
3051 for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i)
3052 {
3053 transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pExclusiveScissors + i));
3054 }
3055 }
3056 vk->vkCmdSetExclusiveScissorNV((VkCommandBuffer)dispatchHandle, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
3057 android::base::endTrace();
3058 break;
3059 }
3060 #endif
3061 #ifdef VK_NV_device_diagnostic_checkpoints
3062 case OP_vkCmdSetCheckpointNV:
3063 {
3064 android::base::beginTrace("vkCmdSetCheckpointNV subdecode");
3065 const void* pCheckpointMarker;
3066 uint8_t* stack_pCheckpointMarker[1];
3067 // WARNING PTR CHECK
3068 memcpy((void**)&pCheckpointMarker, (*readStreamPtrPtr), 8);
3069 android::base::Stream::fromBe64((uint8_t*)&pCheckpointMarker);
3070 *readStreamPtrPtr += 8;
3071 if (pCheckpointMarker)
3072 {
3073 pCheckpointMarker = (void*)stack_pCheckpointMarker;
3074 memcpy((void*)pCheckpointMarker, *readStreamPtrPtr, sizeof(const uint8_t));
3075 *readStreamPtrPtr += sizeof(const uint8_t);
3076 }
3077 vk->vkCmdSetCheckpointNV((VkCommandBuffer)dispatchHandle, pCheckpointMarker);
3078 android::base::endTrace();
3079 break;
3080 }
3081 #endif
3082 #ifdef VK_INTEL_shader_integer_functions2
3083 #endif
3084 #ifdef VK_INTEL_performance_query
3085 case OP_vkCmdSetPerformanceMarkerINTEL:
3086 {
3087 android::base::beginTrace("vkCmdSetPerformanceMarkerINTEL subdecode");
3088 const VkPerformanceMarkerInfoINTEL* pMarkerInfo;
3089 VkPerformanceMarkerInfoINTEL stack_pMarkerInfo[1];
3090 pMarkerInfo = (VkPerformanceMarkerInfoINTEL*)stack_pMarkerInfo;
3091 reservedunmarshal_VkPerformanceMarkerInfoINTEL(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceMarkerInfoINTEL*)(pMarkerInfo), readStreamPtrPtr);
3092 if (pMarkerInfo)
3093 {
3094 transform_tohost_VkPerformanceMarkerInfoINTEL(globalstate, (VkPerformanceMarkerInfoINTEL*)(pMarkerInfo));
3095 }
3096 VkResult vkCmdSetPerformanceMarkerINTEL_VkResult_return = (VkResult)0;
3097 vkCmdSetPerformanceMarkerINTEL_VkResult_return = vk->vkCmdSetPerformanceMarkerINTEL((VkCommandBuffer)dispatchHandle, pMarkerInfo);
3098 android::base::endTrace();
3099 break;
3100 }
3101 case OP_vkCmdSetPerformanceStreamMarkerINTEL:
3102 {
3103 android::base::beginTrace("vkCmdSetPerformanceStreamMarkerINTEL subdecode");
3104 const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo;
3105 VkPerformanceStreamMarkerInfoINTEL stack_pMarkerInfo[1];
3106 pMarkerInfo = (VkPerformanceStreamMarkerInfoINTEL*)stack_pMarkerInfo;
3107 reservedunmarshal_VkPerformanceStreamMarkerInfoINTEL(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceStreamMarkerInfoINTEL*)(pMarkerInfo), readStreamPtrPtr);
3108 if (pMarkerInfo)
3109 {
3110 transform_tohost_VkPerformanceStreamMarkerInfoINTEL(globalstate, (VkPerformanceStreamMarkerInfoINTEL*)(pMarkerInfo));
3111 }
3112 VkResult vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return = (VkResult)0;
3113 vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return = vk->vkCmdSetPerformanceStreamMarkerINTEL((VkCommandBuffer)dispatchHandle, pMarkerInfo);
3114 android::base::endTrace();
3115 break;
3116 }
3117 case OP_vkCmdSetPerformanceOverrideINTEL:
3118 {
3119 android::base::beginTrace("vkCmdSetPerformanceOverrideINTEL subdecode");
3120 const VkPerformanceOverrideInfoINTEL* pOverrideInfo;
3121 VkPerformanceOverrideInfoINTEL stack_pOverrideInfo[1];
3122 pOverrideInfo = (VkPerformanceOverrideInfoINTEL*)stack_pOverrideInfo;
3123 reservedunmarshal_VkPerformanceOverrideInfoINTEL(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceOverrideInfoINTEL*)(pOverrideInfo), readStreamPtrPtr);
3124 if (pOverrideInfo)
3125 {
3126 transform_tohost_VkPerformanceOverrideInfoINTEL(globalstate, (VkPerformanceOverrideInfoINTEL*)(pOverrideInfo));
3127 }
3128 VkResult vkCmdSetPerformanceOverrideINTEL_VkResult_return = (VkResult)0;
3129 vkCmdSetPerformanceOverrideINTEL_VkResult_return = vk->vkCmdSetPerformanceOverrideINTEL((VkCommandBuffer)dispatchHandle, pOverrideInfo);
3130 android::base::endTrace();
3131 break;
3132 }
3133 #endif
3134 #ifdef VK_EXT_pci_bus_info
3135 #endif
3136 #ifdef VK_AMD_display_native_hdr
3137 #endif
3138 #ifdef VK_FUCHSIA_imagepipe_surface
3139 #endif
3140 #ifdef VK_EXT_metal_surface
3141 #endif
3142 #ifdef VK_EXT_fragment_density_map
3143 #endif
3144 #ifdef VK_EXT_scalar_block_layout
3145 #endif
3146 #ifdef VK_GOOGLE_hlsl_functionality1
3147 #endif
3148 #ifdef VK_GOOGLE_decorate_string
3149 #endif
3150 #ifdef VK_EXT_subgroup_size_control
3151 #endif
3152 #ifdef VK_AMD_shader_core_properties2
3153 #endif
3154 #ifdef VK_AMD_device_coherent_memory
3155 #endif
3156 #ifdef VK_EXT_shader_image_atomic_int64
3157 #endif
3158 #ifdef VK_EXT_memory_budget
3159 #endif
3160 #ifdef VK_EXT_memory_priority
3161 #endif
3162 #ifdef VK_NV_dedicated_allocation_image_aliasing
3163 #endif
3164 #ifdef VK_EXT_buffer_device_address
3165 #endif
3166 #ifdef VK_EXT_tooling_info
3167 #endif
3168 #ifdef VK_EXT_separate_stencil_usage
3169 #endif
3170 #ifdef VK_EXT_validation_features
3171 #endif
3172 #ifdef VK_NV_cooperative_matrix
3173 #endif
3174 #ifdef VK_NV_coverage_reduction_mode
3175 #endif
3176 #ifdef VK_EXT_fragment_shader_interlock
3177 #endif
3178 #ifdef VK_EXT_ycbcr_image_arrays
3179 #endif
3180 #ifdef VK_EXT_full_screen_exclusive
3181 #endif
3182 #ifdef VK_EXT_headless_surface
3183 #endif
3184 #ifdef VK_EXT_line_rasterization
3185 case OP_vkCmdSetLineStippleEXT:
3186 {
3187 android::base::beginTrace("vkCmdSetLineStippleEXT subdecode");
3188 uint32_t lineStippleFactor;
3189 uint16_t lineStipplePattern;
3190 memcpy((uint32_t*)&lineStippleFactor, *readStreamPtrPtr, sizeof(uint32_t));
3191 *readStreamPtrPtr += sizeof(uint32_t);
3192 memcpy((uint16_t*)&lineStipplePattern, *readStreamPtrPtr, sizeof(uint16_t));
3193 *readStreamPtrPtr += sizeof(uint16_t);
3194 vk->vkCmdSetLineStippleEXT((VkCommandBuffer)dispatchHandle, lineStippleFactor, lineStipplePattern);
3195 android::base::endTrace();
3196 break;
3197 }
3198 #endif
3199 #ifdef VK_EXT_shader_atomic_float
3200 #endif
3201 #ifdef VK_EXT_host_query_reset
3202 #endif
3203 #ifdef VK_EXT_index_type_uint8
3204 #endif
3205 #ifdef VK_EXT_extended_dynamic_state
3206 case OP_vkCmdSetCullModeEXT:
3207 {
3208 android::base::beginTrace("vkCmdSetCullModeEXT subdecode");
3209 VkCullModeFlags cullMode;
3210 memcpy((VkCullModeFlags*)&cullMode, *readStreamPtrPtr, sizeof(VkCullModeFlags));
3211 *readStreamPtrPtr += sizeof(VkCullModeFlags);
3212 vk->vkCmdSetCullModeEXT((VkCommandBuffer)dispatchHandle, cullMode);
3213 android::base::endTrace();
3214 break;
3215 }
3216 case OP_vkCmdSetFrontFaceEXT:
3217 {
3218 android::base::beginTrace("vkCmdSetFrontFaceEXT subdecode");
3219 VkFrontFace frontFace;
3220 memcpy((VkFrontFace*)&frontFace, *readStreamPtrPtr, sizeof(VkFrontFace));
3221 *readStreamPtrPtr += sizeof(VkFrontFace);
3222 vk->vkCmdSetFrontFaceEXT((VkCommandBuffer)dispatchHandle, frontFace);
3223 android::base::endTrace();
3224 break;
3225 }
3226 case OP_vkCmdSetPrimitiveTopologyEXT:
3227 {
3228 android::base::beginTrace("vkCmdSetPrimitiveTopologyEXT subdecode");
3229 VkPrimitiveTopology primitiveTopology;
3230 memcpy((VkPrimitiveTopology*)&primitiveTopology, *readStreamPtrPtr, sizeof(VkPrimitiveTopology));
3231 *readStreamPtrPtr += sizeof(VkPrimitiveTopology);
3232 vk->vkCmdSetPrimitiveTopologyEXT((VkCommandBuffer)dispatchHandle, primitiveTopology);
3233 android::base::endTrace();
3234 break;
3235 }
3236 case OP_vkCmdSetViewportWithCountEXT:
3237 {
3238 android::base::beginTrace("vkCmdSetViewportWithCountEXT subdecode");
3239 uint32_t viewportCount;
3240 const VkViewport* pViewports;
3241 VkViewport stack_pViewports[MAX_STACK_ITEMS];
3242 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
3243 *readStreamPtrPtr += sizeof(uint32_t);
3244 if (((viewportCount)) <= MAX_STACK_ITEMS)
3245 {
3246 pViewports = (VkViewport*)stack_pViewports;
3247 }
3248 else
3249 {
3250 readStream->alloc((void**)&pViewports, ((viewportCount)) * sizeof(const VkViewport));
3251 }
3252 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
3253 {
3254 reservedunmarshal_VkViewport(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViewport*)(pViewports + i), readStreamPtrPtr);
3255 }
3256 if (pViewports)
3257 {
3258 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
3259 {
3260 transform_tohost_VkViewport(globalstate, (VkViewport*)(pViewports + i));
3261 }
3262 }
3263 vk->vkCmdSetViewportWithCountEXT((VkCommandBuffer)dispatchHandle, viewportCount, pViewports);
3264 android::base::endTrace();
3265 break;
3266 }
3267 case OP_vkCmdSetScissorWithCountEXT:
3268 {
3269 android::base::beginTrace("vkCmdSetScissorWithCountEXT subdecode");
3270 uint32_t scissorCount;
3271 const VkRect2D* pScissors;
3272 VkRect2D stack_pScissors[MAX_STACK_ITEMS];
3273 memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
3274 *readStreamPtrPtr += sizeof(uint32_t);
3275 if (((scissorCount)) <= MAX_STACK_ITEMS)
3276 {
3277 pScissors = (VkRect2D*)stack_pScissors;
3278 }
3279 else
3280 {
3281 readStream->alloc((void**)&pScissors, ((scissorCount)) * sizeof(const VkRect2D));
3282 }
3283 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
3284 {
3285 reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(pScissors + i), readStreamPtrPtr);
3286 }
3287 if (pScissors)
3288 {
3289 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
3290 {
3291 transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pScissors + i));
3292 }
3293 }
3294 vk->vkCmdSetScissorWithCountEXT((VkCommandBuffer)dispatchHandle, scissorCount, pScissors);
3295 android::base::endTrace();
3296 break;
3297 }
3298 case OP_vkCmdBindVertexBuffers2EXT:
3299 {
3300 android::base::beginTrace("vkCmdBindVertexBuffers2EXT subdecode");
3301 uint32_t firstBinding;
3302 uint32_t bindingCount;
3303 const VkBuffer* pBuffers;
3304 VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
3305 const VkDeviceSize* pOffsets;
3306 VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
3307 const VkDeviceSize* pSizes;
3308 VkDeviceSize stack_pSizes[MAX_STACK_ITEMS];
3309 const VkDeviceSize* pStrides;
3310 VkDeviceSize stack_pStrides[MAX_STACK_ITEMS];
3311 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
3312 *readStreamPtrPtr += sizeof(uint32_t);
3313 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
3314 *readStreamPtrPtr += sizeof(uint32_t);
3315 if (((bindingCount)) <= MAX_STACK_ITEMS)
3316 {
3317 pBuffers = (VkBuffer*)stack_pBuffers;
3318 }
3319 else
3320 {
3321 readStream->alloc((void**)&pBuffers, ((bindingCount)) * sizeof(const VkBuffer));
3322 }
3323 if (((bindingCount)))
3324 {
3325 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
3326 *readStreamPtrPtr += 8 * ((bindingCount));
3327 for (uint32_t k = 0; k < ((bindingCount)); ++k)
3328 {
3329 uint64_t tmpval; memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
3330 *(((VkBuffer*)pBuffers) + k) = (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval);
3331 }
3332 }
3333 if (((bindingCount)) <= MAX_STACK_ITEMS)
3334 {
3335 pOffsets = (VkDeviceSize*)stack_pOffsets;
3336 }
3337 else
3338 {
3339 readStream->alloc((void**)&pOffsets, ((bindingCount)) * sizeof(const VkDeviceSize));
3340 }
3341 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr, ((bindingCount)) * sizeof(const VkDeviceSize));
3342 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
3343 // WARNING PTR CHECK
3344 memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
3345 android::base::Stream::fromBe64((uint8_t*)&pSizes);
3346 *readStreamPtrPtr += 8;
3347 if (pSizes)
3348 {
3349 if (((bindingCount)) <= MAX_STACK_ITEMS)
3350 {
3351 pSizes = (VkDeviceSize*)stack_pSizes;
3352 }
3353 else
3354 {
3355 readStream->alloc((void**)&pSizes, ((bindingCount)) * sizeof(const VkDeviceSize));
3356 }
3357 memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr, ((bindingCount)) * sizeof(const VkDeviceSize));
3358 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
3359 }
3360 // WARNING PTR CHECK
3361 memcpy((VkDeviceSize**)&pStrides, (*readStreamPtrPtr), 8);
3362 android::base::Stream::fromBe64((uint8_t*)&pStrides);
3363 *readStreamPtrPtr += 8;
3364 if (pStrides)
3365 {
3366 if (((bindingCount)) <= MAX_STACK_ITEMS)
3367 {
3368 pStrides = (VkDeviceSize*)stack_pStrides;
3369 }
3370 else
3371 {
3372 readStream->alloc((void**)&pStrides, ((bindingCount)) * sizeof(const VkDeviceSize));
3373 }
3374 memcpy((VkDeviceSize*)pStrides, *readStreamPtrPtr, ((bindingCount)) * sizeof(const VkDeviceSize));
3375 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
3376 }
3377 vk->vkCmdBindVertexBuffers2EXT((VkCommandBuffer)dispatchHandle, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
3378 android::base::endTrace();
3379 break;
3380 }
3381 case OP_vkCmdSetDepthTestEnableEXT:
3382 {
3383 android::base::beginTrace("vkCmdSetDepthTestEnableEXT subdecode");
3384 VkBool32 depthTestEnable;
3385 memcpy((VkBool32*)&depthTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
3386 *readStreamPtrPtr += sizeof(VkBool32);
3387 vk->vkCmdSetDepthTestEnableEXT((VkCommandBuffer)dispatchHandle, depthTestEnable);
3388 android::base::endTrace();
3389 break;
3390 }
3391 case OP_vkCmdSetDepthWriteEnableEXT:
3392 {
3393 android::base::beginTrace("vkCmdSetDepthWriteEnableEXT subdecode");
3394 VkBool32 depthWriteEnable;
3395 memcpy((VkBool32*)&depthWriteEnable, *readStreamPtrPtr, sizeof(VkBool32));
3396 *readStreamPtrPtr += sizeof(VkBool32);
3397 vk->vkCmdSetDepthWriteEnableEXT((VkCommandBuffer)dispatchHandle, depthWriteEnable);
3398 android::base::endTrace();
3399 break;
3400 }
3401 case OP_vkCmdSetDepthCompareOpEXT:
3402 {
3403 android::base::beginTrace("vkCmdSetDepthCompareOpEXT subdecode");
3404 VkCompareOp depthCompareOp;
3405 memcpy((VkCompareOp*)&depthCompareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
3406 *readStreamPtrPtr += sizeof(VkCompareOp);
3407 vk->vkCmdSetDepthCompareOpEXT((VkCommandBuffer)dispatchHandle, depthCompareOp);
3408 android::base::endTrace();
3409 break;
3410 }
3411 case OP_vkCmdSetDepthBoundsTestEnableEXT:
3412 {
3413 android::base::beginTrace("vkCmdSetDepthBoundsTestEnableEXT subdecode");
3414 VkBool32 depthBoundsTestEnable;
3415 memcpy((VkBool32*)&depthBoundsTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
3416 *readStreamPtrPtr += sizeof(VkBool32);
3417 vk->vkCmdSetDepthBoundsTestEnableEXT((VkCommandBuffer)dispatchHandle, depthBoundsTestEnable);
3418 android::base::endTrace();
3419 break;
3420 }
3421 case OP_vkCmdSetStencilTestEnableEXT:
3422 {
3423 android::base::beginTrace("vkCmdSetStencilTestEnableEXT subdecode");
3424 VkBool32 stencilTestEnable;
3425 memcpy((VkBool32*)&stencilTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
3426 *readStreamPtrPtr += sizeof(VkBool32);
3427 vk->vkCmdSetStencilTestEnableEXT((VkCommandBuffer)dispatchHandle, stencilTestEnable);
3428 android::base::endTrace();
3429 break;
3430 }
3431 case OP_vkCmdSetStencilOpEXT:
3432 {
3433 android::base::beginTrace("vkCmdSetStencilOpEXT subdecode");
3434 VkStencilFaceFlags faceMask;
3435 VkStencilOp failOp;
3436 VkStencilOp passOp;
3437 VkStencilOp depthFailOp;
3438 VkCompareOp compareOp;
3439 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr, sizeof(VkStencilFaceFlags));
3440 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
3441 memcpy((VkStencilOp*)&failOp, *readStreamPtrPtr, sizeof(VkStencilOp));
3442 *readStreamPtrPtr += sizeof(VkStencilOp);
3443 memcpy((VkStencilOp*)&passOp, *readStreamPtrPtr, sizeof(VkStencilOp));
3444 *readStreamPtrPtr += sizeof(VkStencilOp);
3445 memcpy((VkStencilOp*)&depthFailOp, *readStreamPtrPtr, sizeof(VkStencilOp));
3446 *readStreamPtrPtr += sizeof(VkStencilOp);
3447 memcpy((VkCompareOp*)&compareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
3448 *readStreamPtrPtr += sizeof(VkCompareOp);
3449 vk->vkCmdSetStencilOpEXT((VkCommandBuffer)dispatchHandle, faceMask, failOp, passOp, depthFailOp, compareOp);
3450 android::base::endTrace();
3451 break;
3452 }
3453 #endif
3454 #ifdef VK_EXT_shader_demote_to_helper_invocation
3455 #endif
3456 #ifdef VK_NV_device_generated_commands
3457 case OP_vkCmdPreprocessGeneratedCommandsNV:
3458 {
3459 android::base::beginTrace("vkCmdPreprocessGeneratedCommandsNV subdecode");
3460 const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo;
3461 VkGeneratedCommandsInfoNV stack_pGeneratedCommandsInfo[1];
3462 pGeneratedCommandsInfo = (VkGeneratedCommandsInfoNV*)stack_pGeneratedCommandsInfo;
3463 reservedunmarshal_VkGeneratedCommandsInfoNV(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkGeneratedCommandsInfoNV*)(pGeneratedCommandsInfo), readStreamPtrPtr);
3464 if (pGeneratedCommandsInfo)
3465 {
3466 transform_tohost_VkGeneratedCommandsInfoNV(globalstate, (VkGeneratedCommandsInfoNV*)(pGeneratedCommandsInfo));
3467 }
3468 vk->vkCmdPreprocessGeneratedCommandsNV((VkCommandBuffer)dispatchHandle, pGeneratedCommandsInfo);
3469 android::base::endTrace();
3470 break;
3471 }
3472 case OP_vkCmdExecuteGeneratedCommandsNV:
3473 {
3474 android::base::beginTrace("vkCmdExecuteGeneratedCommandsNV subdecode");
3475 VkBool32 isPreprocessed;
3476 const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo;
3477 VkGeneratedCommandsInfoNV stack_pGeneratedCommandsInfo[1];
3478 memcpy((VkBool32*)&isPreprocessed, *readStreamPtrPtr, sizeof(VkBool32));
3479 *readStreamPtrPtr += sizeof(VkBool32);
3480 pGeneratedCommandsInfo = (VkGeneratedCommandsInfoNV*)stack_pGeneratedCommandsInfo;
3481 reservedunmarshal_VkGeneratedCommandsInfoNV(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkGeneratedCommandsInfoNV*)(pGeneratedCommandsInfo), readStreamPtrPtr);
3482 if (pGeneratedCommandsInfo)
3483 {
3484 transform_tohost_VkGeneratedCommandsInfoNV(globalstate, (VkGeneratedCommandsInfoNV*)(pGeneratedCommandsInfo));
3485 }
3486 vk->vkCmdExecuteGeneratedCommandsNV((VkCommandBuffer)dispatchHandle, isPreprocessed, pGeneratedCommandsInfo);
3487 android::base::endTrace();
3488 break;
3489 }
3490 case OP_vkCmdBindPipelineShaderGroupNV:
3491 {
3492 android::base::beginTrace("vkCmdBindPipelineShaderGroupNV subdecode");
3493 VkPipelineBindPoint pipelineBindPoint;
3494 VkPipeline pipeline;
3495 uint32_t groupIndex;
3496 memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr, sizeof(VkPipelineBindPoint));
3497 *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
3498 uint64_t cgen_var_0;
3499 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
3500 *readStreamPtrPtr += 1 * 8;
3501 *(VkPipeline*)&pipeline = (VkPipeline)unbox_VkPipeline((VkPipeline)(*&cgen_var_0));
3502 memcpy((uint32_t*)&groupIndex, *readStreamPtrPtr, sizeof(uint32_t));
3503 *readStreamPtrPtr += sizeof(uint32_t);
3504 vk->vkCmdBindPipelineShaderGroupNV((VkCommandBuffer)dispatchHandle, pipelineBindPoint, pipeline, groupIndex);
3505 android::base::endTrace();
3506 break;
3507 }
3508 #endif
3509 #ifdef VK_EXT_texel_buffer_alignment
3510 #endif
3511 #ifdef VK_QCOM_render_pass_transform
3512 #endif
3513 #ifdef VK_EXT_device_memory_report
3514 #endif
3515 #ifdef VK_EXT_robustness2
3516 #endif
3517 #ifdef VK_EXT_custom_border_color
3518 #endif
3519 #ifdef VK_GOOGLE_user_type
3520 #endif
3521 #ifdef VK_EXT_private_data
3522 #endif
3523 #ifdef VK_EXT_pipeline_creation_cache_control
3524 #endif
3525 #ifdef VK_NV_device_diagnostics_config
3526 #endif
3527 #ifdef VK_QCOM_render_pass_store_ops
3528 #endif
3529 #ifdef VK_NV_fragment_shading_rate_enums
3530 case OP_vkCmdSetFragmentShadingRateEnumNV:
3531 {
3532 android::base::beginTrace("vkCmdSetFragmentShadingRateEnumNV subdecode");
3533 VkFragmentShadingRateNV shadingRate;
3534 VkFragmentShadingRateCombinerOpKHR combinerOps[2];
3535 memcpy((VkFragmentShadingRateNV*)&shadingRate, *readStreamPtrPtr, sizeof(VkFragmentShadingRateNV));
3536 *readStreamPtrPtr += sizeof(VkFragmentShadingRateNV);
3537 memcpy((VkFragmentShadingRateCombinerOpKHR*)combinerOps, *readStreamPtrPtr, 2 * sizeof(const VkFragmentShadingRateCombinerOpKHR));
3538 *readStreamPtrPtr += 2 * sizeof(const VkFragmentShadingRateCombinerOpKHR);
3539 vk->vkCmdSetFragmentShadingRateEnumNV((VkCommandBuffer)dispatchHandle, shadingRate, combinerOps);
3540 android::base::endTrace();
3541 break;
3542 }
3543 #endif
3544 #ifdef VK_EXT_fragment_density_map2
3545 #endif
3546 #ifdef VK_QCOM_rotated_copy_commands
3547 #endif
3548 #ifdef VK_EXT_image_robustness
3549 #endif
3550 #ifdef VK_EXT_4444_formats
3551 #endif
3552 #ifdef VK_EXT_directfb_surface
3553 #endif
3554 #ifdef VK_GOOGLE_gfxstream
3555 case OP_vkBeginCommandBufferAsyncGOOGLE:
3556 {
3557 android::base::beginTrace("vkBeginCommandBufferAsyncGOOGLE subdecode");
3558 const VkCommandBufferBeginInfo* pBeginInfo;
3559 VkCommandBufferBeginInfo stack_pBeginInfo[1];
3560 pBeginInfo = (VkCommandBufferBeginInfo*)stack_pBeginInfo;
3561 reservedunmarshal_VkCommandBufferBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCommandBufferBeginInfo*)(pBeginInfo), readStreamPtrPtr);
3562 if (pBeginInfo)
3563 {
3564 transform_tohost_VkCommandBufferBeginInfo(globalstate, (VkCommandBufferBeginInfo*)(pBeginInfo));
3565 }
3566 this->on_vkBeginCommandBufferAsyncGOOGLE(pool, (VkCommandBuffer)(boxed_dispatchHandle), pBeginInfo);
3567 android::base::endTrace();
3568 break;
3569 }
3570 case OP_vkEndCommandBufferAsyncGOOGLE:
3571 {
3572 android::base::beginTrace("vkEndCommandBufferAsyncGOOGLE subdecode");
3573 this->on_vkEndCommandBufferAsyncGOOGLE(pool, (VkCommandBuffer)(boxed_dispatchHandle));
3574 android::base::endTrace();
3575 break;
3576 }
3577 case OP_vkResetCommandBufferAsyncGOOGLE:
3578 {
3579 android::base::beginTrace("vkResetCommandBufferAsyncGOOGLE subdecode");
3580 VkCommandBufferResetFlags flags;
3581 memcpy((VkCommandBufferResetFlags*)&flags, *readStreamPtrPtr, sizeof(VkCommandBufferResetFlags));
3582 *readStreamPtrPtr += sizeof(VkCommandBufferResetFlags);
3583 this->on_vkResetCommandBufferAsyncGOOGLE(pool, (VkCommandBuffer)(boxed_dispatchHandle), flags);
3584 android::base::endTrace();
3585 break;
3586 }
3587 case OP_vkCommandBufferHostSyncGOOGLE:
3588 {
3589 android::base::beginTrace("vkCommandBufferHostSyncGOOGLE subdecode");
3590 uint32_t needHostSync;
3591 uint32_t sequenceNumber;
3592 memcpy((uint32_t*)&needHostSync, *readStreamPtrPtr, sizeof(uint32_t));
3593 *readStreamPtrPtr += sizeof(uint32_t);
3594 memcpy((uint32_t*)&sequenceNumber, *readStreamPtrPtr, sizeof(uint32_t));
3595 *readStreamPtrPtr += sizeof(uint32_t);
3596 this->on_vkCommandBufferHostSyncGOOGLE(pool, (VkCommandBuffer)(boxed_dispatchHandle), needHostSync, sequenceNumber);
3597 android::base::endTrace();
3598 break;
3599 }
3600 #endif
3601 #ifdef VK_KHR_acceleration_structure
3602 case OP_vkCmdBuildAccelerationStructuresKHR:
3603 {
3604 android::base::beginTrace("vkCmdBuildAccelerationStructuresKHR subdecode");
3605 uint32_t infoCount;
3606 const VkAccelerationStructureBuildGeometryInfoKHR* pInfos;
3607 VkAccelerationStructureBuildGeometryInfoKHR stack_pInfos[MAX_STACK_ITEMS];
3608 const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos;
3609 VkAccelerationStructureBuildRangeInfoKHR* stack_ppBuildRangeInfos[MAX_STACK_ITEMS];
3610 memcpy((uint32_t*)&infoCount, *readStreamPtrPtr, sizeof(uint32_t));
3611 *readStreamPtrPtr += sizeof(uint32_t);
3612 if (((infoCount)) <= MAX_STACK_ITEMS)
3613 {
3614 pInfos = (VkAccelerationStructureBuildGeometryInfoKHR*)stack_pInfos;
3615 }
3616 else
3617 {
3618 readStream->alloc((void**)&pInfos, ((infoCount)) * sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
3619 }
3620 for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
3621 {
3622 reservedunmarshal_VkAccelerationStructureBuildGeometryInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(pInfos + i), readStreamPtrPtr);
3623 }
3624 if (pInfos)
3625 {
3626 for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
3627 {
3628 transform_tohost_VkAccelerationStructureBuildGeometryInfoKHR(globalstate, (VkAccelerationStructureBuildGeometryInfoKHR*)(pInfos + i));
3629 }
3630 }
3631 (void)ppBuildRangeInfos;
3632 vk->vkCmdBuildAccelerationStructuresKHR((VkCommandBuffer)dispatchHandle, infoCount, pInfos, ppBuildRangeInfos);
3633 android::base::endTrace();
3634 break;
3635 }
3636 case OP_vkCmdBuildAccelerationStructuresIndirectKHR:
3637 {
3638 android::base::beginTrace("vkCmdBuildAccelerationStructuresIndirectKHR subdecode");
3639 uint32_t infoCount;
3640 const VkAccelerationStructureBuildGeometryInfoKHR* pInfos;
3641 VkAccelerationStructureBuildGeometryInfoKHR stack_pInfos[MAX_STACK_ITEMS];
3642 const VkDeviceAddress* pIndirectDeviceAddresses;
3643 VkDeviceAddress stack_pIndirectDeviceAddresses[MAX_STACK_ITEMS];
3644 const uint32_t* pIndirectStrides;
3645 uint32_t stack_pIndirectStrides[MAX_STACK_ITEMS];
3646 const uint32_t* const* ppMaxPrimitiveCounts;
3647 uint32_t* stack_ppMaxPrimitiveCounts[MAX_STACK_ITEMS];
3648 memcpy((uint32_t*)&infoCount, *readStreamPtrPtr, sizeof(uint32_t));
3649 *readStreamPtrPtr += sizeof(uint32_t);
3650 if (((infoCount)) <= MAX_STACK_ITEMS)
3651 {
3652 pInfos = (VkAccelerationStructureBuildGeometryInfoKHR*)stack_pInfos;
3653 }
3654 else
3655 {
3656 readStream->alloc((void**)&pInfos, ((infoCount)) * sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
3657 }
3658 for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
3659 {
3660 reservedunmarshal_VkAccelerationStructureBuildGeometryInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(pInfos + i), readStreamPtrPtr);
3661 }
3662 if (((infoCount)) <= MAX_STACK_ITEMS)
3663 {
3664 pIndirectDeviceAddresses = (VkDeviceAddress*)stack_pIndirectDeviceAddresses;
3665 }
3666 else
3667 {
3668 readStream->alloc((void**)&pIndirectDeviceAddresses, ((infoCount)) * sizeof(const VkDeviceAddress));
3669 }
3670 memcpy((VkDeviceAddress*)pIndirectDeviceAddresses, *readStreamPtrPtr, ((infoCount)) * sizeof(const VkDeviceAddress));
3671 *readStreamPtrPtr += ((infoCount)) * sizeof(const VkDeviceAddress);
3672 if (((infoCount)) <= MAX_STACK_ITEMS)
3673 {
3674 pIndirectStrides = (uint32_t*)stack_pIndirectStrides;
3675 }
3676 else
3677 {
3678 readStream->alloc((void**)&pIndirectStrides, ((infoCount)) * sizeof(const uint32_t));
3679 }
3680 memcpy((uint32_t*)pIndirectStrides, *readStreamPtrPtr, ((infoCount)) * sizeof(const uint32_t));
3681 *readStreamPtrPtr += ((infoCount)) * sizeof(const uint32_t);
3682 if (pInfos)
3683 {
3684 for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
3685 {
3686 transform_tohost_VkAccelerationStructureBuildGeometryInfoKHR(globalstate, (VkAccelerationStructureBuildGeometryInfoKHR*)(pInfos + i));
3687 }
3688 }
3689 (void)ppMaxPrimitiveCounts;
3690 vk->vkCmdBuildAccelerationStructuresIndirectKHR((VkCommandBuffer)dispatchHandle, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
3691 android::base::endTrace();
3692 break;
3693 }
3694 case OP_vkCmdCopyAccelerationStructureKHR:
3695 {
3696 android::base::beginTrace("vkCmdCopyAccelerationStructureKHR subdecode");
3697 const VkCopyAccelerationStructureInfoKHR* pInfo;
3698 VkCopyAccelerationStructureInfoKHR stack_pInfo[1];
3699 pInfo = (VkCopyAccelerationStructureInfoKHR*)stack_pInfo;
3700 reservedunmarshal_VkCopyAccelerationStructureInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyAccelerationStructureInfoKHR*)(pInfo), readStreamPtrPtr);
3701 if (pInfo)
3702 {
3703 transform_tohost_VkCopyAccelerationStructureInfoKHR(globalstate, (VkCopyAccelerationStructureInfoKHR*)(pInfo));
3704 }
3705 vk->vkCmdCopyAccelerationStructureKHR((VkCommandBuffer)dispatchHandle, pInfo);
3706 android::base::endTrace();
3707 break;
3708 }
3709 case OP_vkCmdCopyAccelerationStructureToMemoryKHR:
3710 {
3711 android::base::beginTrace("vkCmdCopyAccelerationStructureToMemoryKHR subdecode");
3712 const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo;
3713 VkCopyAccelerationStructureToMemoryInfoKHR stack_pInfo[1];
3714 pInfo = (VkCopyAccelerationStructureToMemoryInfoKHR*)stack_pInfo;
3715 reservedunmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyAccelerationStructureToMemoryInfoKHR*)(pInfo), readStreamPtrPtr);
3716 if (pInfo)
3717 {
3718 transform_tohost_VkCopyAccelerationStructureToMemoryInfoKHR(globalstate, (VkCopyAccelerationStructureToMemoryInfoKHR*)(pInfo));
3719 }
3720 vk->vkCmdCopyAccelerationStructureToMemoryKHR((VkCommandBuffer)dispatchHandle, pInfo);
3721 android::base::endTrace();
3722 break;
3723 }
3724 case OP_vkCmdCopyMemoryToAccelerationStructureKHR:
3725 {
3726 android::base::beginTrace("vkCmdCopyMemoryToAccelerationStructureKHR subdecode");
3727 const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo;
3728 VkCopyMemoryToAccelerationStructureInfoKHR stack_pInfo[1];
3729 pInfo = (VkCopyMemoryToAccelerationStructureInfoKHR*)stack_pInfo;
3730 reservedunmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyMemoryToAccelerationStructureInfoKHR*)(pInfo), readStreamPtrPtr);
3731 if (pInfo)
3732 {
3733 transform_tohost_VkCopyMemoryToAccelerationStructureInfoKHR(globalstate, (VkCopyMemoryToAccelerationStructureInfoKHR*)(pInfo));
3734 }
3735 vk->vkCmdCopyMemoryToAccelerationStructureKHR((VkCommandBuffer)dispatchHandle, pInfo);
3736 android::base::endTrace();
3737 break;
3738 }
3739 case OP_vkCmdWriteAccelerationStructuresPropertiesKHR:
3740 {
3741 android::base::beginTrace("vkCmdWriteAccelerationStructuresPropertiesKHR subdecode");
3742 uint32_t accelerationStructureCount;
3743 const VkAccelerationStructureKHR* pAccelerationStructures;
3744 VkAccelerationStructureKHR stack_pAccelerationStructures[MAX_STACK_ITEMS];
3745 VkQueryType queryType;
3746 VkQueryPool queryPool;
3747 uint32_t firstQuery;
3748 memcpy((uint32_t*)&accelerationStructureCount, *readStreamPtrPtr, sizeof(uint32_t));
3749 *readStreamPtrPtr += sizeof(uint32_t);
3750 if (((accelerationStructureCount)) <= MAX_STACK_ITEMS)
3751 {
3752 pAccelerationStructures = (VkAccelerationStructureKHR*)stack_pAccelerationStructures;
3753 }
3754 else
3755 {
3756 readStream->alloc((void**)&pAccelerationStructures, ((accelerationStructureCount)) * sizeof(const VkAccelerationStructureKHR));
3757 }
3758 if (((accelerationStructureCount)))
3759 {
3760 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
3761 *readStreamPtrPtr += 8 * ((accelerationStructureCount));
3762 for (uint32_t k = 0; k < ((accelerationStructureCount)); ++k)
3763 {
3764 uint64_t tmpval; memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
3765 *(((VkAccelerationStructureKHR*)pAccelerationStructures) + k) = (VkAccelerationStructureKHR)unbox_VkAccelerationStructureKHR((VkAccelerationStructureKHR)tmpval);
3766 }
3767 }
3768 memcpy((VkQueryType*)&queryType, *readStreamPtrPtr, sizeof(VkQueryType));
3769 *readStreamPtrPtr += sizeof(VkQueryType);
3770 uint64_t cgen_var_1;
3771 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
3772 *readStreamPtrPtr += 1 * 8;
3773 *(VkQueryPool*)&queryPool = (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
3774 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
3775 *readStreamPtrPtr += sizeof(uint32_t);
3776 vk->vkCmdWriteAccelerationStructuresPropertiesKHR((VkCommandBuffer)dispatchHandle, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
3777 android::base::endTrace();
3778 break;
3779 }
3780 #endif
3781 #ifdef VK_KHR_ray_tracing_pipeline
3782 case OP_vkCmdTraceRaysKHR:
3783 {
3784 android::base::beginTrace("vkCmdTraceRaysKHR subdecode");
3785 const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable;
3786 VkStridedDeviceAddressRegionKHR stack_pRaygenShaderBindingTable[1];
3787 const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable;
3788 VkStridedDeviceAddressRegionKHR stack_pMissShaderBindingTable[1];
3789 const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable;
3790 VkStridedDeviceAddressRegionKHR stack_pHitShaderBindingTable[1];
3791 const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable;
3792 VkStridedDeviceAddressRegionKHR stack_pCallableShaderBindingTable[1];
3793 uint32_t width;
3794 uint32_t height;
3795 uint32_t depth;
3796 pRaygenShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)stack_pRaygenShaderBindingTable;
3797 reservedunmarshal_VkStridedDeviceAddressRegionKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable), readStreamPtrPtr);
3798 pMissShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)stack_pMissShaderBindingTable;
3799 reservedunmarshal_VkStridedDeviceAddressRegionKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable), readStreamPtrPtr);
3800 pHitShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)stack_pHitShaderBindingTable;
3801 reservedunmarshal_VkStridedDeviceAddressRegionKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable), readStreamPtrPtr);
3802 pCallableShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)stack_pCallableShaderBindingTable;
3803 reservedunmarshal_VkStridedDeviceAddressRegionKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable), readStreamPtrPtr);
3804 memcpy((uint32_t*)&width, *readStreamPtrPtr, sizeof(uint32_t));
3805 *readStreamPtrPtr += sizeof(uint32_t);
3806 memcpy((uint32_t*)&height, *readStreamPtrPtr, sizeof(uint32_t));
3807 *readStreamPtrPtr += sizeof(uint32_t);
3808 memcpy((uint32_t*)&depth, *readStreamPtrPtr, sizeof(uint32_t));
3809 *readStreamPtrPtr += sizeof(uint32_t);
3810 if (pRaygenShaderBindingTable)
3811 {
3812 transform_tohost_VkStridedDeviceAddressRegionKHR(globalstate, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable));
3813 }
3814 if (pMissShaderBindingTable)
3815 {
3816 transform_tohost_VkStridedDeviceAddressRegionKHR(globalstate, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable));
3817 }
3818 if (pHitShaderBindingTable)
3819 {
3820 transform_tohost_VkStridedDeviceAddressRegionKHR(globalstate, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable));
3821 }
3822 if (pCallableShaderBindingTable)
3823 {
3824 transform_tohost_VkStridedDeviceAddressRegionKHR(globalstate, (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable));
3825 }
3826 vk->vkCmdTraceRaysKHR((VkCommandBuffer)dispatchHandle, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
3827 android::base::endTrace();
3828 break;
3829 }
3830 case OP_vkCmdTraceRaysIndirectKHR:
3831 {
3832 android::base::beginTrace("vkCmdTraceRaysIndirectKHR subdecode");
3833 const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable;
3834 VkStridedDeviceAddressRegionKHR stack_pRaygenShaderBindingTable[1];
3835 const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable;
3836 VkStridedDeviceAddressRegionKHR stack_pMissShaderBindingTable[1];
3837 const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable;
3838 VkStridedDeviceAddressRegionKHR stack_pHitShaderBindingTable[1];
3839 const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable;
3840 VkStridedDeviceAddressRegionKHR stack_pCallableShaderBindingTable[1];
3841 VkDeviceAddress indirectDeviceAddress;
3842 pRaygenShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)stack_pRaygenShaderBindingTable;
3843 reservedunmarshal_VkStridedDeviceAddressRegionKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable), readStreamPtrPtr);
3844 pMissShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)stack_pMissShaderBindingTable;
3845 reservedunmarshal_VkStridedDeviceAddressRegionKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable), readStreamPtrPtr);
3846 pHitShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)stack_pHitShaderBindingTable;
3847 reservedunmarshal_VkStridedDeviceAddressRegionKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable), readStreamPtrPtr);
3848 pCallableShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)stack_pCallableShaderBindingTable;
3849 reservedunmarshal_VkStridedDeviceAddressRegionKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable), readStreamPtrPtr);
3850 memcpy((VkDeviceAddress*)&indirectDeviceAddress, *readStreamPtrPtr, sizeof(VkDeviceAddress));
3851 *readStreamPtrPtr += sizeof(VkDeviceAddress);
3852 if (pRaygenShaderBindingTable)
3853 {
3854 transform_tohost_VkStridedDeviceAddressRegionKHR(globalstate, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable));
3855 }
3856 if (pMissShaderBindingTable)
3857 {
3858 transform_tohost_VkStridedDeviceAddressRegionKHR(globalstate, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable));
3859 }
3860 if (pHitShaderBindingTable)
3861 {
3862 transform_tohost_VkStridedDeviceAddressRegionKHR(globalstate, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable));
3863 }
3864 if (pCallableShaderBindingTable)
3865 {
3866 transform_tohost_VkStridedDeviceAddressRegionKHR(globalstate, (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable));
3867 }
3868 vk->vkCmdTraceRaysIndirectKHR((VkCommandBuffer)dispatchHandle, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress);
3869 android::base::endTrace();
3870 break;
3871 }
3872 case OP_vkCmdSetRayTracingPipelineStackSizeKHR:
3873 {
3874 android::base::beginTrace("vkCmdSetRayTracingPipelineStackSizeKHR subdecode");
3875 uint32_t pipelineStackSize;
3876 memcpy((uint32_t*)&pipelineStackSize, *readStreamPtrPtr, sizeof(uint32_t));
3877 *readStreamPtrPtr += sizeof(uint32_t);
3878 vk->vkCmdSetRayTracingPipelineStackSizeKHR((VkCommandBuffer)dispatchHandle, pipelineStackSize);
3879 android::base::endTrace();
3880 break;
3881 }
3882 #endif
3883 #ifdef VK_KHR_ray_query
3884 #endif
3885 default:
3886 {
3887 fprintf(stderr, "Fatal, unrecognized opcode %u\n", opcode);
3888 abort();
3889 return ptr - (unsigned char *)buf;
3890 }
3891 }
3892 ++count; if (count % 1000 == 0) { pool->freeAll(); };
3893 ptr += packetLen;
3894 }
3895 pool->freeAll();
3896 return ptr - (unsigned char*)buf;;
3897 }
3898
3899
3900