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 //
18 // (impl) generated by scripts/genvk.py -registry
19 // ../../../../../hardware/google/gfxstream/codegen/vulkan/vulkan-docs-next/xml/vk.xml
20 // -registryGfxstream xml/vk_gfxstream.xml cereal -o
21 // ../../../../../hardware/google/gfxstream/host/vulkan/cereal
22 //
23 // Please do not modify directly;
24 // re-run mesa3d/src/gfxstream/codegen/generate-gfxstream-vulkan.sh,
25 // or directly from Python by defining:
26 // VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
27 // VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
28 // CEREAL_OUTPUT_DIR: Where to put the generated sources.
29 //
30 // python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
31 // $CEREAL_OUTPUT_DIR
32 //
33 #define MAX_STACK_ITEMS 16
34 #define MAX_PACKET_LENGTH (400 * 1024 * 1024) // 400MB
35 #define CC_LIKELY(exp) (__builtin_expect(!!(exp), true))
36 #define CC_UNLIKELY(exp) (__builtin_expect(!!(exp), false))
subDecode(VulkanMemReadingStream * readStream,VulkanDispatch * vk,void * boxed_dispatchHandle,void * dispatchHandle,VkDeviceSize subDecodeDataSize,const void * pSubDecodeData,const VkDecoderContext & context)37 size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* boxed_dispatchHandle,
38 void* dispatchHandle, VkDeviceSize subDecodeDataSize, const void* pSubDecodeData,
39 const VkDecoderContext& context) {
40 auto& metricsLogger = *context.metricsLogger;
41 uint32_t count = 0;
42 unsigned char* buf = (unsigned char*)pSubDecodeData;
43 android::base::BumpPool* pool = readStream->pool();
44 unsigned char* ptr = (unsigned char*)pSubDecodeData;
45 const unsigned char* const end = (const unsigned char*)buf + subDecodeDataSize;
46 VkDecoderGlobalState* globalstate = VkDecoderGlobalState::get();
47 while (end - ptr >= 8) {
48 uint32_t opcode = *(uint32_t*)ptr;
49 uint32_t packetLen = *(uint32_t*)(ptr + 4);
50
51 // packetLen should be at least 8 (op code and packet length) and should not be excessively
52 // large
53 if (packetLen < 8 || packetLen > MAX_PACKET_LENGTH) {
54 WARN("Bad packet length %d detected, subdecode may fail", packetLen);
55 metricsLogger.logMetricEvent(MetricEventBadPacketLength{.len = packetLen});
56 }
57
58 if (end - ptr < packetLen) return ptr - (unsigned char*)buf;
59 readStream->setBuf((uint8_t*)(ptr + 8));
60 uint8_t* readStreamPtr = readStream->getBuf();
61 uint8_t** readStreamPtrPtr = &readStreamPtr;
62 switch (opcode) {
63 #ifdef VK_VERSION_1_0
64 case OP_vkBeginCommandBuffer: {
65 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
66 "VkSubDecoder vkBeginCommandBuffer");
67 const VkCommandBufferBeginInfo* pBeginInfo;
68 VkCommandBufferBeginInfo stack_pBeginInfo[1];
69 pBeginInfo = (VkCommandBufferBeginInfo*)stack_pBeginInfo;
70 reservedunmarshal_VkCommandBufferBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
71 (VkCommandBufferBeginInfo*)(pBeginInfo),
72 readStreamPtrPtr);
73 if (pBeginInfo) {
74 transform_tohost_VkCommandBufferBeginInfo(
75 globalstate, (VkCommandBufferBeginInfo*)(pBeginInfo));
76 }
77 VkResult vkBeginCommandBuffer_VkResult_return = VK_ERROR_OUT_OF_HOST_MEMORY;
78 if (CC_LIKELY(vk)) {
79 vkBeginCommandBuffer_VkResult_return = this->on_vkBeginCommandBuffer(
80 pool, nullptr, (VkCommandBuffer)(boxed_dispatchHandle), pBeginInfo,
81 context);
82 }
83 if ((vkBeginCommandBuffer_VkResult_return) == VK_ERROR_DEVICE_LOST)
84 this->on_DeviceLost();
85 this->on_CheckOutOfMemory(vkBeginCommandBuffer_VkResult_return, opcode, context);
86 break;
87 }
88 case OP_vkEndCommandBuffer: {
89 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
90 "VkSubDecoder vkEndCommandBuffer");
91 VkResult vkEndCommandBuffer_VkResult_return = VK_ERROR_OUT_OF_HOST_MEMORY;
92 if (CC_LIKELY(vk)) {
93 vkEndCommandBuffer_VkResult_return = this->on_vkEndCommandBuffer(
94 pool, nullptr, (VkCommandBuffer)(boxed_dispatchHandle), context);
95 }
96 if ((vkEndCommandBuffer_VkResult_return) == VK_ERROR_DEVICE_LOST)
97 this->on_DeviceLost();
98 this->on_CheckOutOfMemory(vkEndCommandBuffer_VkResult_return, opcode, context);
99 break;
100 }
101 case OP_vkResetCommandBuffer: {
102 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
103 "VkSubDecoder vkResetCommandBuffer");
104 VkCommandBufferResetFlags flags;
105 memcpy((VkCommandBufferResetFlags*)&flags, *readStreamPtrPtr,
106 sizeof(VkCommandBufferResetFlags));
107 *readStreamPtrPtr += sizeof(VkCommandBufferResetFlags);
108 VkResult vkResetCommandBuffer_VkResult_return = VK_ERROR_OUT_OF_HOST_MEMORY;
109 if (CC_LIKELY(vk)) {
110 vkResetCommandBuffer_VkResult_return = this->on_vkResetCommandBuffer(
111 pool, nullptr, (VkCommandBuffer)(boxed_dispatchHandle), flags);
112 }
113 if ((vkResetCommandBuffer_VkResult_return) == VK_ERROR_DEVICE_LOST)
114 this->on_DeviceLost();
115 this->on_CheckOutOfMemory(vkResetCommandBuffer_VkResult_return, opcode, context);
116 break;
117 }
118 case OP_vkCmdBindPipeline: {
119 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
120 "VkSubDecoder vkCmdBindPipeline");
121 VkPipelineBindPoint pipelineBindPoint;
122 VkPipeline pipeline;
123 memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
124 sizeof(VkPipelineBindPoint));
125 *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
126 uint64_t cgen_var_0;
127 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
128 *readStreamPtrPtr += 1 * 8;
129 *(VkPipeline*)&pipeline = (VkPipeline)unbox_VkPipeline((VkPipeline)(*&cgen_var_0));
130 if (CC_LIKELY(vk)) {
131 this->on_vkCmdBindPipeline(pool, nullptr,
132 (VkCommandBuffer)(boxed_dispatchHandle),
133 pipelineBindPoint, pipeline);
134 }
135 break;
136 }
137 case OP_vkCmdSetViewport: {
138 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
139 "VkSubDecoder vkCmdSetViewport");
140 uint32_t firstViewport;
141 uint32_t viewportCount;
142 const VkViewport* pViewports;
143 VkViewport stack_pViewports[MAX_STACK_ITEMS];
144 memcpy((uint32_t*)&firstViewport, *readStreamPtrPtr, sizeof(uint32_t));
145 *readStreamPtrPtr += sizeof(uint32_t);
146 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
147 *readStreamPtrPtr += sizeof(uint32_t);
148 if (((viewportCount)) <= MAX_STACK_ITEMS) {
149 pViewports = (VkViewport*)stack_pViewports;
150 } else {
151 readStream->alloc((void**)&pViewports,
152 ((viewportCount)) * sizeof(const VkViewport));
153 }
154 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
155 reservedunmarshal_VkViewport(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
156 (VkViewport*)(pViewports + i), readStreamPtrPtr);
157 }
158 if (pViewports) {
159 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
160 transform_tohost_VkViewport(globalstate, (VkViewport*)(pViewports + i));
161 }
162 }
163 if (CC_LIKELY(vk)) {
164 vk->vkCmdSetViewport((VkCommandBuffer)dispatchHandle, firstViewport,
165 viewportCount, pViewports);
166 }
167 break;
168 }
169 case OP_vkCmdSetScissor: {
170 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
171 "VkSubDecoder vkCmdSetScissor");
172 uint32_t firstScissor;
173 uint32_t scissorCount;
174 const VkRect2D* pScissors;
175 VkRect2D stack_pScissors[MAX_STACK_ITEMS];
176 memcpy((uint32_t*)&firstScissor, *readStreamPtrPtr, sizeof(uint32_t));
177 *readStreamPtrPtr += sizeof(uint32_t);
178 memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
179 *readStreamPtrPtr += sizeof(uint32_t);
180 if (((scissorCount)) <= MAX_STACK_ITEMS) {
181 pScissors = (VkRect2D*)stack_pScissors;
182 } else {
183 readStream->alloc((void**)&pScissors,
184 ((scissorCount)) * sizeof(const VkRect2D));
185 }
186 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
187 reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
188 (VkRect2D*)(pScissors + i), readStreamPtrPtr);
189 }
190 if (pScissors) {
191 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
192 transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pScissors + i));
193 }
194 }
195 if (CC_LIKELY(vk)) {
196 vk->vkCmdSetScissor((VkCommandBuffer)dispatchHandle, firstScissor, scissorCount,
197 pScissors);
198 }
199 break;
200 }
201 case OP_vkCmdSetLineWidth: {
202 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
203 "VkSubDecoder vkCmdSetLineWidth");
204 float lineWidth;
205 memcpy((float*)&lineWidth, *readStreamPtrPtr, sizeof(float));
206 *readStreamPtrPtr += sizeof(float);
207 if (CC_LIKELY(vk)) {
208 vk->vkCmdSetLineWidth((VkCommandBuffer)dispatchHandle, lineWidth);
209 }
210 break;
211 }
212 case OP_vkCmdSetDepthBias: {
213 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
214 "VkSubDecoder vkCmdSetDepthBias");
215 float depthBiasConstantFactor;
216 float depthBiasClamp;
217 float depthBiasSlopeFactor;
218 memcpy((float*)&depthBiasConstantFactor, *readStreamPtrPtr, sizeof(float));
219 *readStreamPtrPtr += sizeof(float);
220 memcpy((float*)&depthBiasClamp, *readStreamPtrPtr, sizeof(float));
221 *readStreamPtrPtr += sizeof(float);
222 memcpy((float*)&depthBiasSlopeFactor, *readStreamPtrPtr, sizeof(float));
223 *readStreamPtrPtr += sizeof(float);
224 if (CC_LIKELY(vk)) {
225 vk->vkCmdSetDepthBias((VkCommandBuffer)dispatchHandle, depthBiasConstantFactor,
226 depthBiasClamp, depthBiasSlopeFactor);
227 }
228 break;
229 }
230 case OP_vkCmdSetBlendConstants: {
231 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
232 "VkSubDecoder vkCmdSetBlendConstants");
233 float blendConstants[4];
234 memcpy((float*)blendConstants, *readStreamPtrPtr, 4 * sizeof(const float));
235 *readStreamPtrPtr += 4 * sizeof(const float);
236 if (CC_LIKELY(vk)) {
237 vk->vkCmdSetBlendConstants((VkCommandBuffer)dispatchHandle, blendConstants);
238 }
239 break;
240 }
241 case OP_vkCmdSetDepthBounds: {
242 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
243 "VkSubDecoder vkCmdSetDepthBounds");
244 float minDepthBounds;
245 float maxDepthBounds;
246 memcpy((float*)&minDepthBounds, *readStreamPtrPtr, sizeof(float));
247 *readStreamPtrPtr += sizeof(float);
248 memcpy((float*)&maxDepthBounds, *readStreamPtrPtr, sizeof(float));
249 *readStreamPtrPtr += sizeof(float);
250 if (CC_LIKELY(vk)) {
251 vk->vkCmdSetDepthBounds((VkCommandBuffer)dispatchHandle, minDepthBounds,
252 maxDepthBounds);
253 }
254 break;
255 }
256 case OP_vkCmdSetStencilCompareMask: {
257 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
258 "VkSubDecoder vkCmdSetStencilCompareMask");
259 VkStencilFaceFlags faceMask;
260 uint32_t compareMask;
261 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
262 sizeof(VkStencilFaceFlags));
263 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
264 memcpy((uint32_t*)&compareMask, *readStreamPtrPtr, sizeof(uint32_t));
265 *readStreamPtrPtr += sizeof(uint32_t);
266 if (CC_LIKELY(vk)) {
267 vk->vkCmdSetStencilCompareMask((VkCommandBuffer)dispatchHandle, faceMask,
268 compareMask);
269 }
270 break;
271 }
272 case OP_vkCmdSetStencilWriteMask: {
273 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
274 "VkSubDecoder vkCmdSetStencilWriteMask");
275 VkStencilFaceFlags faceMask;
276 uint32_t writeMask;
277 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
278 sizeof(VkStencilFaceFlags));
279 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
280 memcpy((uint32_t*)&writeMask, *readStreamPtrPtr, sizeof(uint32_t));
281 *readStreamPtrPtr += sizeof(uint32_t);
282 if (CC_LIKELY(vk)) {
283 vk->vkCmdSetStencilWriteMask((VkCommandBuffer)dispatchHandle, faceMask,
284 writeMask);
285 }
286 break;
287 }
288 case OP_vkCmdSetStencilReference: {
289 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
290 "VkSubDecoder vkCmdSetStencilReference");
291 VkStencilFaceFlags faceMask;
292 uint32_t reference;
293 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
294 sizeof(VkStencilFaceFlags));
295 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
296 memcpy((uint32_t*)&reference, *readStreamPtrPtr, sizeof(uint32_t));
297 *readStreamPtrPtr += sizeof(uint32_t);
298 if (CC_LIKELY(vk)) {
299 vk->vkCmdSetStencilReference((VkCommandBuffer)dispatchHandle, faceMask,
300 reference);
301 }
302 break;
303 }
304 case OP_vkCmdBindDescriptorSets: {
305 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
306 "VkSubDecoder vkCmdBindDescriptorSets");
307 VkPipelineBindPoint pipelineBindPoint;
308 VkPipelineLayout layout;
309 uint32_t firstSet;
310 uint32_t descriptorSetCount;
311 const VkDescriptorSet* pDescriptorSets;
312 VkDescriptorSet stack_pDescriptorSets[MAX_STACK_ITEMS];
313 uint32_t dynamicOffsetCount;
314 const uint32_t* pDynamicOffsets;
315 uint32_t stack_pDynamicOffsets[MAX_STACK_ITEMS];
316 memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
317 sizeof(VkPipelineBindPoint));
318 *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
319 uint64_t cgen_var_0;
320 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
321 *readStreamPtrPtr += 1 * 8;
322 *(VkPipelineLayout*)&layout =
323 (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
324 memcpy((uint32_t*)&firstSet, *readStreamPtrPtr, sizeof(uint32_t));
325 *readStreamPtrPtr += sizeof(uint32_t);
326 memcpy((uint32_t*)&descriptorSetCount, *readStreamPtrPtr, sizeof(uint32_t));
327 *readStreamPtrPtr += sizeof(uint32_t);
328 if (((descriptorSetCount)) <= MAX_STACK_ITEMS) {
329 pDescriptorSets = (VkDescriptorSet*)stack_pDescriptorSets;
330 } else {
331 readStream->alloc((void**)&pDescriptorSets,
332 ((descriptorSetCount)) * sizeof(const VkDescriptorSet));
333 }
334 if (((descriptorSetCount))) {
335 uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
336 *readStreamPtrPtr += 8 * ((descriptorSetCount));
337 for (uint32_t k = 0; k < ((descriptorSetCount)); ++k) {
338 uint64_t tmpval;
339 memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
340 *(((VkDescriptorSet*)pDescriptorSets) + k) =
341 tmpval ? (VkDescriptorSet)unbox_VkDescriptorSet((VkDescriptorSet)tmpval)
342 : VK_NULL_HANDLE;
343 }
344 }
345 memcpy((uint32_t*)&dynamicOffsetCount, *readStreamPtrPtr, sizeof(uint32_t));
346 *readStreamPtrPtr += sizeof(uint32_t);
347 if (((dynamicOffsetCount)) <= MAX_STACK_ITEMS) {
348 pDynamicOffsets = (uint32_t*)stack_pDynamicOffsets;
349 } else {
350 readStream->alloc((void**)&pDynamicOffsets,
351 ((dynamicOffsetCount)) * sizeof(const uint32_t));
352 }
353 memcpy((uint32_t*)pDynamicOffsets, *readStreamPtrPtr,
354 ((dynamicOffsetCount)) * sizeof(const uint32_t));
355 *readStreamPtrPtr += ((dynamicOffsetCount)) * sizeof(const uint32_t);
356 if (CC_LIKELY(vk)) {
357 this->on_vkCmdBindDescriptorSets(
358 pool, nullptr, (VkCommandBuffer)(boxed_dispatchHandle), pipelineBindPoint,
359 layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount,
360 pDynamicOffsets);
361 }
362 break;
363 }
364 case OP_vkCmdBindIndexBuffer: {
365 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
366 "VkSubDecoder vkCmdBindIndexBuffer");
367 VkBuffer buffer;
368 VkDeviceSize offset;
369 VkIndexType indexType;
370 uint64_t cgen_var_0;
371 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
372 *readStreamPtrPtr += 1 * 8;
373 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
374 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
375 *readStreamPtrPtr += sizeof(VkDeviceSize);
376 memcpy((VkIndexType*)&indexType, *readStreamPtrPtr, sizeof(VkIndexType));
377 *readStreamPtrPtr += sizeof(VkIndexType);
378 if (CC_LIKELY(vk)) {
379 vk->vkCmdBindIndexBuffer((VkCommandBuffer)dispatchHandle, buffer, offset,
380 indexType);
381 }
382 break;
383 }
384 case OP_vkCmdBindVertexBuffers: {
385 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
386 "VkSubDecoder vkCmdBindVertexBuffers");
387 uint32_t firstBinding;
388 uint32_t bindingCount;
389 const VkBuffer* pBuffers;
390 VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
391 const VkDeviceSize* pOffsets;
392 VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
393 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
394 *readStreamPtrPtr += sizeof(uint32_t);
395 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
396 *readStreamPtrPtr += sizeof(uint32_t);
397 if (((bindingCount)) <= MAX_STACK_ITEMS) {
398 pBuffers = (VkBuffer*)stack_pBuffers;
399 } else {
400 readStream->alloc((void**)&pBuffers, ((bindingCount)) * sizeof(const VkBuffer));
401 }
402 if (((bindingCount))) {
403 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
404 *readStreamPtrPtr += 8 * ((bindingCount));
405 for (uint32_t k = 0; k < ((bindingCount)); ++k) {
406 uint64_t tmpval;
407 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
408 *(((VkBuffer*)pBuffers) + k) =
409 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval) : VK_NULL_HANDLE;
410 }
411 }
412 if (((bindingCount)) <= MAX_STACK_ITEMS) {
413 pOffsets = (VkDeviceSize*)stack_pOffsets;
414 } else {
415 readStream->alloc((void**)&pOffsets,
416 ((bindingCount)) * sizeof(const VkDeviceSize));
417 }
418 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
419 ((bindingCount)) * sizeof(const VkDeviceSize));
420 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
421 if (CC_LIKELY(vk)) {
422 vk->vkCmdBindVertexBuffers((VkCommandBuffer)dispatchHandle, firstBinding,
423 bindingCount, pBuffers, pOffsets);
424 }
425 break;
426 }
427 case OP_vkCmdDraw: {
428 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkSubDecoder vkCmdDraw");
429 uint32_t vertexCount;
430 uint32_t instanceCount;
431 uint32_t firstVertex;
432 uint32_t firstInstance;
433 memcpy((uint32_t*)&vertexCount, *readStreamPtrPtr, sizeof(uint32_t));
434 *readStreamPtrPtr += sizeof(uint32_t);
435 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
436 *readStreamPtrPtr += sizeof(uint32_t);
437 memcpy((uint32_t*)&firstVertex, *readStreamPtrPtr, sizeof(uint32_t));
438 *readStreamPtrPtr += sizeof(uint32_t);
439 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
440 *readStreamPtrPtr += sizeof(uint32_t);
441 if (CC_LIKELY(vk)) {
442 vk->vkCmdDraw((VkCommandBuffer)dispatchHandle, vertexCount, instanceCount,
443 firstVertex, firstInstance);
444 }
445 break;
446 }
447 case OP_vkCmdDrawIndexed: {
448 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
449 "VkSubDecoder vkCmdDrawIndexed");
450 uint32_t indexCount;
451 uint32_t instanceCount;
452 uint32_t firstIndex;
453 int32_t vertexOffset;
454 uint32_t firstInstance;
455 memcpy((uint32_t*)&indexCount, *readStreamPtrPtr, sizeof(uint32_t));
456 *readStreamPtrPtr += sizeof(uint32_t);
457 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
458 *readStreamPtrPtr += sizeof(uint32_t);
459 memcpy((uint32_t*)&firstIndex, *readStreamPtrPtr, sizeof(uint32_t));
460 *readStreamPtrPtr += sizeof(uint32_t);
461 memcpy((int32_t*)&vertexOffset, *readStreamPtrPtr, sizeof(int32_t));
462 *readStreamPtrPtr += sizeof(int32_t);
463 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
464 *readStreamPtrPtr += sizeof(uint32_t);
465 if (CC_LIKELY(vk)) {
466 vk->vkCmdDrawIndexed((VkCommandBuffer)dispatchHandle, indexCount, instanceCount,
467 firstIndex, vertexOffset, firstInstance);
468 }
469 break;
470 }
471 case OP_vkCmdDrawIndirect: {
472 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
473 "VkSubDecoder vkCmdDrawIndirect");
474 VkBuffer buffer;
475 VkDeviceSize offset;
476 uint32_t drawCount;
477 uint32_t stride;
478 uint64_t cgen_var_0;
479 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
480 *readStreamPtrPtr += 1 * 8;
481 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
482 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
483 *readStreamPtrPtr += sizeof(VkDeviceSize);
484 memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
485 *readStreamPtrPtr += sizeof(uint32_t);
486 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
487 *readStreamPtrPtr += sizeof(uint32_t);
488 if (CC_LIKELY(vk)) {
489 vk->vkCmdDrawIndirect((VkCommandBuffer)dispatchHandle, buffer, offset,
490 drawCount, stride);
491 }
492 break;
493 }
494 case OP_vkCmdDrawIndexedIndirect: {
495 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
496 "VkSubDecoder vkCmdDrawIndexedIndirect");
497 VkBuffer buffer;
498 VkDeviceSize offset;
499 uint32_t drawCount;
500 uint32_t stride;
501 uint64_t cgen_var_0;
502 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
503 *readStreamPtrPtr += 1 * 8;
504 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
505 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
506 *readStreamPtrPtr += sizeof(VkDeviceSize);
507 memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
508 *readStreamPtrPtr += sizeof(uint32_t);
509 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
510 *readStreamPtrPtr += sizeof(uint32_t);
511 if (CC_LIKELY(vk)) {
512 vk->vkCmdDrawIndexedIndirect((VkCommandBuffer)dispatchHandle, buffer, offset,
513 drawCount, stride);
514 }
515 break;
516 }
517 case OP_vkCmdDispatch: {
518 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
519 "VkSubDecoder vkCmdDispatch");
520 uint32_t groupCountX;
521 uint32_t groupCountY;
522 uint32_t groupCountZ;
523 memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
524 *readStreamPtrPtr += sizeof(uint32_t);
525 memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
526 *readStreamPtrPtr += sizeof(uint32_t);
527 memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
528 *readStreamPtrPtr += sizeof(uint32_t);
529 if (CC_LIKELY(vk)) {
530 vk->vkCmdDispatch((VkCommandBuffer)dispatchHandle, groupCountX, groupCountY,
531 groupCountZ);
532 }
533 break;
534 }
535 case OP_vkCmdDispatchIndirect: {
536 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
537 "VkSubDecoder vkCmdDispatchIndirect");
538 VkBuffer buffer;
539 VkDeviceSize offset;
540 uint64_t cgen_var_0;
541 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
542 *readStreamPtrPtr += 1 * 8;
543 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
544 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
545 *readStreamPtrPtr += sizeof(VkDeviceSize);
546 if (CC_LIKELY(vk)) {
547 vk->vkCmdDispatchIndirect((VkCommandBuffer)dispatchHandle, buffer, offset);
548 }
549 break;
550 }
551 case OP_vkCmdCopyBuffer: {
552 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
553 "VkSubDecoder vkCmdCopyBuffer");
554 VkBuffer srcBuffer;
555 VkBuffer dstBuffer;
556 uint32_t regionCount;
557 const VkBufferCopy* pRegions;
558 VkBufferCopy stack_pRegions[MAX_STACK_ITEMS];
559 uint64_t cgen_var_0;
560 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
561 *readStreamPtrPtr += 1 * 8;
562 *(VkBuffer*)&srcBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
563 uint64_t cgen_var_1;
564 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
565 *readStreamPtrPtr += 1 * 8;
566 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
567 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
568 *readStreamPtrPtr += sizeof(uint32_t);
569 if (((regionCount)) <= MAX_STACK_ITEMS) {
570 pRegions = (VkBufferCopy*)stack_pRegions;
571 } else {
572 readStream->alloc((void**)&pRegions,
573 ((regionCount)) * sizeof(const VkBufferCopy));
574 }
575 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
576 reservedunmarshal_VkBufferCopy(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
577 (VkBufferCopy*)(pRegions + i), readStreamPtrPtr);
578 }
579 if (pRegions) {
580 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
581 transform_tohost_VkBufferCopy(globalstate, (VkBufferCopy*)(pRegions + i));
582 }
583 }
584 if (CC_LIKELY(vk)) {
585 vk->vkCmdCopyBuffer((VkCommandBuffer)dispatchHandle, srcBuffer, dstBuffer,
586 regionCount, pRegions);
587 }
588 break;
589 }
590 case OP_vkCmdCopyImage: {
591 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
592 "VkSubDecoder vkCmdCopyImage");
593 VkImage srcImage;
594 VkImageLayout srcImageLayout;
595 VkImage dstImage;
596 VkImageLayout dstImageLayout;
597 uint32_t regionCount;
598 const VkImageCopy* pRegions;
599 VkImageCopy stack_pRegions[MAX_STACK_ITEMS];
600 uint64_t cgen_var_0;
601 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
602 *readStreamPtrPtr += 1 * 8;
603 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
604 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
605 *readStreamPtrPtr += sizeof(VkImageLayout);
606 uint64_t cgen_var_1;
607 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
608 *readStreamPtrPtr += 1 * 8;
609 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
610 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
611 *readStreamPtrPtr += sizeof(VkImageLayout);
612 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
613 *readStreamPtrPtr += sizeof(uint32_t);
614 if (((regionCount)) <= MAX_STACK_ITEMS) {
615 pRegions = (VkImageCopy*)stack_pRegions;
616 } else {
617 readStream->alloc((void**)&pRegions,
618 ((regionCount)) * sizeof(const VkImageCopy));
619 }
620 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
621 reservedunmarshal_VkImageCopy(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
622 (VkImageCopy*)(pRegions + i), readStreamPtrPtr);
623 }
624 if (pRegions) {
625 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
626 transform_tohost_VkImageCopy(globalstate, (VkImageCopy*)(pRegions + i));
627 }
628 }
629 if (CC_LIKELY(vk)) {
630 this->on_vkCmdCopyImage(pool, nullptr, (VkCommandBuffer)(boxed_dispatchHandle),
631 srcImage, srcImageLayout, dstImage, dstImageLayout,
632 regionCount, pRegions);
633 }
634 break;
635 }
636 case OP_vkCmdBlitImage: {
637 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
638 "VkSubDecoder vkCmdBlitImage");
639 VkImage srcImage;
640 VkImageLayout srcImageLayout;
641 VkImage dstImage;
642 VkImageLayout dstImageLayout;
643 uint32_t regionCount;
644 const VkImageBlit* pRegions;
645 VkImageBlit stack_pRegions[MAX_STACK_ITEMS];
646 VkFilter filter;
647 uint64_t cgen_var_0;
648 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
649 *readStreamPtrPtr += 1 * 8;
650 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
651 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
652 *readStreamPtrPtr += sizeof(VkImageLayout);
653 uint64_t cgen_var_1;
654 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
655 *readStreamPtrPtr += 1 * 8;
656 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
657 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
658 *readStreamPtrPtr += sizeof(VkImageLayout);
659 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
660 *readStreamPtrPtr += sizeof(uint32_t);
661 if (((regionCount)) <= MAX_STACK_ITEMS) {
662 pRegions = (VkImageBlit*)stack_pRegions;
663 } else {
664 readStream->alloc((void**)&pRegions,
665 ((regionCount)) * sizeof(const VkImageBlit));
666 }
667 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
668 reservedunmarshal_VkImageBlit(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
669 (VkImageBlit*)(pRegions + i), readStreamPtrPtr);
670 }
671 memcpy((VkFilter*)&filter, *readStreamPtrPtr, sizeof(VkFilter));
672 *readStreamPtrPtr += sizeof(VkFilter);
673 if (pRegions) {
674 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
675 transform_tohost_VkImageBlit(globalstate, (VkImageBlit*)(pRegions + i));
676 }
677 }
678 if (CC_LIKELY(vk)) {
679 vk->vkCmdBlitImage((VkCommandBuffer)dispatchHandle, srcImage, srcImageLayout,
680 dstImage, dstImageLayout, regionCount, pRegions, filter);
681 }
682 break;
683 }
684 case OP_vkCmdCopyBufferToImage: {
685 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
686 "VkSubDecoder vkCmdCopyBufferToImage");
687 VkBuffer srcBuffer;
688 VkImage dstImage;
689 VkImageLayout dstImageLayout;
690 uint32_t regionCount;
691 const VkBufferImageCopy* pRegions;
692 VkBufferImageCopy stack_pRegions[MAX_STACK_ITEMS];
693 uint64_t cgen_var_0;
694 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
695 *readStreamPtrPtr += 1 * 8;
696 *(VkBuffer*)&srcBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
697 uint64_t cgen_var_1;
698 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
699 *readStreamPtrPtr += 1 * 8;
700 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
701 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
702 *readStreamPtrPtr += sizeof(VkImageLayout);
703 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
704 *readStreamPtrPtr += sizeof(uint32_t);
705 if (((regionCount)) <= MAX_STACK_ITEMS) {
706 pRegions = (VkBufferImageCopy*)stack_pRegions;
707 } else {
708 readStream->alloc((void**)&pRegions,
709 ((regionCount)) * sizeof(const VkBufferImageCopy));
710 }
711 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
712 reservedunmarshal_VkBufferImageCopy(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
713 (VkBufferImageCopy*)(pRegions + i),
714 readStreamPtrPtr);
715 }
716 if (pRegions) {
717 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
718 transform_tohost_VkBufferImageCopy(globalstate,
719 (VkBufferImageCopy*)(pRegions + i));
720 }
721 }
722 if (CC_LIKELY(vk)) {
723 this->on_vkCmdCopyBufferToImage(
724 pool, nullptr, (VkCommandBuffer)(boxed_dispatchHandle), srcBuffer, dstImage,
725 dstImageLayout, regionCount, pRegions, context);
726 }
727 break;
728 }
729 case OP_vkCmdCopyImageToBuffer: {
730 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
731 "VkSubDecoder vkCmdCopyImageToBuffer");
732 VkImage srcImage;
733 VkImageLayout srcImageLayout;
734 VkBuffer dstBuffer;
735 uint32_t regionCount;
736 const VkBufferImageCopy* pRegions;
737 VkBufferImageCopy stack_pRegions[MAX_STACK_ITEMS];
738 uint64_t cgen_var_0;
739 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
740 *readStreamPtrPtr += 1 * 8;
741 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
742 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
743 *readStreamPtrPtr += sizeof(VkImageLayout);
744 uint64_t cgen_var_1;
745 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
746 *readStreamPtrPtr += 1 * 8;
747 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
748 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
749 *readStreamPtrPtr += sizeof(uint32_t);
750 if (((regionCount)) <= MAX_STACK_ITEMS) {
751 pRegions = (VkBufferImageCopy*)stack_pRegions;
752 } else {
753 readStream->alloc((void**)&pRegions,
754 ((regionCount)) * sizeof(const VkBufferImageCopy));
755 }
756 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
757 reservedunmarshal_VkBufferImageCopy(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
758 (VkBufferImageCopy*)(pRegions + i),
759 readStreamPtrPtr);
760 }
761 if (pRegions) {
762 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
763 transform_tohost_VkBufferImageCopy(globalstate,
764 (VkBufferImageCopy*)(pRegions + i));
765 }
766 }
767 if (CC_LIKELY(vk)) {
768 this->on_vkCmdCopyImageToBuffer(
769 pool, nullptr, (VkCommandBuffer)(boxed_dispatchHandle), srcImage,
770 srcImageLayout, dstBuffer, regionCount, pRegions);
771 }
772 break;
773 }
774 case OP_vkCmdUpdateBuffer: {
775 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
776 "VkSubDecoder vkCmdUpdateBuffer");
777 VkBuffer dstBuffer;
778 VkDeviceSize dstOffset;
779 VkDeviceSize dataSize;
780 const void* pData;
781 uint8_t* stack_pData[MAX_STACK_ITEMS];
782 uint64_t cgen_var_0;
783 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
784 *readStreamPtrPtr += 1 * 8;
785 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
786 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
787 *readStreamPtrPtr += sizeof(VkDeviceSize);
788 memcpy((VkDeviceSize*)&dataSize, *readStreamPtrPtr, sizeof(VkDeviceSize));
789 *readStreamPtrPtr += sizeof(VkDeviceSize);
790 if (((dataSize)) <= MAX_STACK_ITEMS) {
791 pData = (void*)stack_pData;
792 } else {
793 readStream->alloc((void**)&pData, ((dataSize)) * sizeof(const uint8_t));
794 }
795 memcpy((void*)pData, *readStreamPtrPtr, ((dataSize)) * sizeof(const uint8_t));
796 *readStreamPtrPtr += ((dataSize)) * sizeof(const uint8_t);
797 if (CC_LIKELY(vk)) {
798 vk->vkCmdUpdateBuffer((VkCommandBuffer)dispatchHandle, dstBuffer, dstOffset,
799 dataSize, pData);
800 }
801 break;
802 }
803 case OP_vkCmdFillBuffer: {
804 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
805 "VkSubDecoder vkCmdFillBuffer");
806 VkBuffer dstBuffer;
807 VkDeviceSize dstOffset;
808 VkDeviceSize size;
809 uint32_t data;
810 uint64_t cgen_var_0;
811 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
812 *readStreamPtrPtr += 1 * 8;
813 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
814 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
815 *readStreamPtrPtr += sizeof(VkDeviceSize);
816 memcpy((VkDeviceSize*)&size, *readStreamPtrPtr, sizeof(VkDeviceSize));
817 *readStreamPtrPtr += sizeof(VkDeviceSize);
818 memcpy((uint32_t*)&data, *readStreamPtrPtr, sizeof(uint32_t));
819 *readStreamPtrPtr += sizeof(uint32_t);
820 if (CC_LIKELY(vk)) {
821 vk->vkCmdFillBuffer((VkCommandBuffer)dispatchHandle, dstBuffer, dstOffset, size,
822 data);
823 }
824 break;
825 }
826 case OP_vkCmdClearColorImage: {
827 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
828 "VkSubDecoder vkCmdClearColorImage");
829 VkImage image;
830 VkImageLayout imageLayout;
831 const VkClearColorValue* pColor;
832 VkClearColorValue stack_pColor[1];
833 uint32_t rangeCount;
834 const VkImageSubresourceRange* pRanges;
835 VkImageSubresourceRange stack_pRanges[MAX_STACK_ITEMS];
836 uint64_t cgen_var_0;
837 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
838 *readStreamPtrPtr += 1 * 8;
839 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
840 memcpy((VkImageLayout*)&imageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
841 *readStreamPtrPtr += sizeof(VkImageLayout);
842 pColor = (VkClearColorValue*)stack_pColor;
843 reservedunmarshal_VkClearColorValue(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
844 (VkClearColorValue*)(pColor), readStreamPtrPtr);
845 memcpy((uint32_t*)&rangeCount, *readStreamPtrPtr, sizeof(uint32_t));
846 *readStreamPtrPtr += sizeof(uint32_t);
847 if (((rangeCount)) <= MAX_STACK_ITEMS) {
848 pRanges = (VkImageSubresourceRange*)stack_pRanges;
849 } else {
850 readStream->alloc((void**)&pRanges,
851 ((rangeCount)) * sizeof(const VkImageSubresourceRange));
852 }
853 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
854 reservedunmarshal_VkImageSubresourceRange(
855 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
856 (VkImageSubresourceRange*)(pRanges + i), readStreamPtrPtr);
857 }
858 if (pColor) {
859 transform_tohost_VkClearColorValue(globalstate, (VkClearColorValue*)(pColor));
860 }
861 if (pRanges) {
862 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
863 transform_tohost_VkImageSubresourceRange(
864 globalstate, (VkImageSubresourceRange*)(pRanges + i));
865 }
866 }
867 if (CC_LIKELY(vk)) {
868 vk->vkCmdClearColorImage((VkCommandBuffer)dispatchHandle, image, imageLayout,
869 pColor, rangeCount, pRanges);
870 }
871 break;
872 }
873 case OP_vkCmdClearDepthStencilImage: {
874 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
875 "VkSubDecoder vkCmdClearDepthStencilImage");
876 VkImage image;
877 VkImageLayout imageLayout;
878 const VkClearDepthStencilValue* pDepthStencil;
879 VkClearDepthStencilValue stack_pDepthStencil[1];
880 uint32_t rangeCount;
881 const VkImageSubresourceRange* pRanges;
882 VkImageSubresourceRange stack_pRanges[MAX_STACK_ITEMS];
883 uint64_t cgen_var_0;
884 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
885 *readStreamPtrPtr += 1 * 8;
886 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
887 memcpy((VkImageLayout*)&imageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
888 *readStreamPtrPtr += sizeof(VkImageLayout);
889 pDepthStencil = (VkClearDepthStencilValue*)stack_pDepthStencil;
890 reservedunmarshal_VkClearDepthStencilValue(
891 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
892 (VkClearDepthStencilValue*)(pDepthStencil), readStreamPtrPtr);
893 memcpy((uint32_t*)&rangeCount, *readStreamPtrPtr, sizeof(uint32_t));
894 *readStreamPtrPtr += sizeof(uint32_t);
895 if (((rangeCount)) <= MAX_STACK_ITEMS) {
896 pRanges = (VkImageSubresourceRange*)stack_pRanges;
897 } else {
898 readStream->alloc((void**)&pRanges,
899 ((rangeCount)) * sizeof(const VkImageSubresourceRange));
900 }
901 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
902 reservedunmarshal_VkImageSubresourceRange(
903 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
904 (VkImageSubresourceRange*)(pRanges + i), readStreamPtrPtr);
905 }
906 if (pDepthStencil) {
907 transform_tohost_VkClearDepthStencilValue(
908 globalstate, (VkClearDepthStencilValue*)(pDepthStencil));
909 }
910 if (pRanges) {
911 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
912 transform_tohost_VkImageSubresourceRange(
913 globalstate, (VkImageSubresourceRange*)(pRanges + i));
914 }
915 }
916 if (CC_LIKELY(vk)) {
917 vk->vkCmdClearDepthStencilImage((VkCommandBuffer)dispatchHandle, image,
918 imageLayout, pDepthStencil, rangeCount,
919 pRanges);
920 }
921 break;
922 }
923 case OP_vkCmdClearAttachments: {
924 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
925 "VkSubDecoder vkCmdClearAttachments");
926 uint32_t attachmentCount;
927 const VkClearAttachment* pAttachments;
928 VkClearAttachment stack_pAttachments[MAX_STACK_ITEMS];
929 uint32_t rectCount;
930 const VkClearRect* pRects;
931 VkClearRect stack_pRects[MAX_STACK_ITEMS];
932 memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
933 *readStreamPtrPtr += sizeof(uint32_t);
934 if (((attachmentCount)) <= MAX_STACK_ITEMS) {
935 pAttachments = (VkClearAttachment*)stack_pAttachments;
936 } else {
937 readStream->alloc((void**)&pAttachments,
938 ((attachmentCount)) * sizeof(const VkClearAttachment));
939 }
940 for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
941 reservedunmarshal_VkClearAttachment(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
942 (VkClearAttachment*)(pAttachments + i),
943 readStreamPtrPtr);
944 }
945 memcpy((uint32_t*)&rectCount, *readStreamPtrPtr, sizeof(uint32_t));
946 *readStreamPtrPtr += sizeof(uint32_t);
947 if (((rectCount)) <= MAX_STACK_ITEMS) {
948 pRects = (VkClearRect*)stack_pRects;
949 } else {
950 readStream->alloc((void**)&pRects, ((rectCount)) * sizeof(const VkClearRect));
951 }
952 for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i) {
953 reservedunmarshal_VkClearRect(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
954 (VkClearRect*)(pRects + i), readStreamPtrPtr);
955 }
956 if (pAttachments) {
957 for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
958 transform_tohost_VkClearAttachment(globalstate,
959 (VkClearAttachment*)(pAttachments + i));
960 }
961 }
962 if (pRects) {
963 for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i) {
964 transform_tohost_VkClearRect(globalstate, (VkClearRect*)(pRects + i));
965 }
966 }
967 if (CC_LIKELY(vk)) {
968 vk->vkCmdClearAttachments((VkCommandBuffer)dispatchHandle, attachmentCount,
969 pAttachments, rectCount, pRects);
970 }
971 break;
972 }
973 case OP_vkCmdResolveImage: {
974 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
975 "VkSubDecoder vkCmdResolveImage");
976 VkImage srcImage;
977 VkImageLayout srcImageLayout;
978 VkImage dstImage;
979 VkImageLayout dstImageLayout;
980 uint32_t regionCount;
981 const VkImageResolve* pRegions;
982 VkImageResolve stack_pRegions[MAX_STACK_ITEMS];
983 uint64_t cgen_var_0;
984 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
985 *readStreamPtrPtr += 1 * 8;
986 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
987 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
988 *readStreamPtrPtr += sizeof(VkImageLayout);
989 uint64_t cgen_var_1;
990 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
991 *readStreamPtrPtr += 1 * 8;
992 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
993 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
994 *readStreamPtrPtr += sizeof(VkImageLayout);
995 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
996 *readStreamPtrPtr += sizeof(uint32_t);
997 if (((regionCount)) <= MAX_STACK_ITEMS) {
998 pRegions = (VkImageResolve*)stack_pRegions;
999 } else {
1000 readStream->alloc((void**)&pRegions,
1001 ((regionCount)) * sizeof(const VkImageResolve));
1002 }
1003 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
1004 reservedunmarshal_VkImageResolve(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1005 (VkImageResolve*)(pRegions + i),
1006 readStreamPtrPtr);
1007 }
1008 if (pRegions) {
1009 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
1010 transform_tohost_VkImageResolve(globalstate,
1011 (VkImageResolve*)(pRegions + i));
1012 }
1013 }
1014 if (CC_LIKELY(vk)) {
1015 vk->vkCmdResolveImage((VkCommandBuffer)dispatchHandle, srcImage, srcImageLayout,
1016 dstImage, dstImageLayout, regionCount, pRegions);
1017 }
1018 break;
1019 }
1020 case OP_vkCmdSetEvent: {
1021 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1022 "VkSubDecoder vkCmdSetEvent");
1023 VkEvent event;
1024 VkPipelineStageFlags stageMask;
1025 uint64_t cgen_var_0;
1026 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1027 *readStreamPtrPtr += 1 * 8;
1028 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
1029 memcpy((VkPipelineStageFlags*)&stageMask, *readStreamPtrPtr,
1030 sizeof(VkPipelineStageFlags));
1031 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1032 if (CC_LIKELY(vk)) {
1033 vk->vkCmdSetEvent((VkCommandBuffer)dispatchHandle, event, stageMask);
1034 }
1035 break;
1036 }
1037 case OP_vkCmdResetEvent: {
1038 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1039 "VkSubDecoder vkCmdResetEvent");
1040 VkEvent event;
1041 VkPipelineStageFlags stageMask;
1042 uint64_t cgen_var_0;
1043 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1044 *readStreamPtrPtr += 1 * 8;
1045 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
1046 memcpy((VkPipelineStageFlags*)&stageMask, *readStreamPtrPtr,
1047 sizeof(VkPipelineStageFlags));
1048 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1049 if (CC_LIKELY(vk)) {
1050 vk->vkCmdResetEvent((VkCommandBuffer)dispatchHandle, event, stageMask);
1051 }
1052 break;
1053 }
1054 case OP_vkCmdWaitEvents: {
1055 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1056 "VkSubDecoder vkCmdWaitEvents");
1057 uint32_t eventCount;
1058 const VkEvent* pEvents;
1059 VkEvent stack_pEvents[MAX_STACK_ITEMS];
1060 VkPipelineStageFlags srcStageMask;
1061 VkPipelineStageFlags dstStageMask;
1062 uint32_t memoryBarrierCount;
1063 const VkMemoryBarrier* pMemoryBarriers;
1064 VkMemoryBarrier stack_pMemoryBarriers[MAX_STACK_ITEMS];
1065 uint32_t bufferMemoryBarrierCount;
1066 const VkBufferMemoryBarrier* pBufferMemoryBarriers;
1067 VkBufferMemoryBarrier stack_pBufferMemoryBarriers[MAX_STACK_ITEMS];
1068 uint32_t imageMemoryBarrierCount;
1069 const VkImageMemoryBarrier* pImageMemoryBarriers;
1070 VkImageMemoryBarrier stack_pImageMemoryBarriers[MAX_STACK_ITEMS];
1071 memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
1072 *readStreamPtrPtr += sizeof(uint32_t);
1073 if (((eventCount)) <= MAX_STACK_ITEMS) {
1074 pEvents = (VkEvent*)stack_pEvents;
1075 } else {
1076 readStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
1077 }
1078 if (((eventCount))) {
1079 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
1080 *readStreamPtrPtr += 8 * ((eventCount));
1081 for (uint32_t k = 0; k < ((eventCount)); ++k) {
1082 uint64_t tmpval;
1083 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
1084 *(((VkEvent*)pEvents) + k) =
1085 tmpval ? (VkEvent)unbox_VkEvent((VkEvent)tmpval) : VK_NULL_HANDLE;
1086 }
1087 }
1088 memcpy((VkPipelineStageFlags*)&srcStageMask, *readStreamPtrPtr,
1089 sizeof(VkPipelineStageFlags));
1090 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1091 memcpy((VkPipelineStageFlags*)&dstStageMask, *readStreamPtrPtr,
1092 sizeof(VkPipelineStageFlags));
1093 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1094 memcpy((uint32_t*)&memoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1095 *readStreamPtrPtr += sizeof(uint32_t);
1096 if (((memoryBarrierCount)) <= MAX_STACK_ITEMS) {
1097 pMemoryBarriers = (VkMemoryBarrier*)stack_pMemoryBarriers;
1098 } else {
1099 readStream->alloc((void**)&pMemoryBarriers,
1100 ((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
1101 }
1102 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
1103 reservedunmarshal_VkMemoryBarrier(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1104 (VkMemoryBarrier*)(pMemoryBarriers + i),
1105 readStreamPtrPtr);
1106 }
1107 memcpy((uint32_t*)&bufferMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1108 *readStreamPtrPtr += sizeof(uint32_t);
1109 if (((bufferMemoryBarrierCount)) <= MAX_STACK_ITEMS) {
1110 pBufferMemoryBarriers = (VkBufferMemoryBarrier*)stack_pBufferMemoryBarriers;
1111 } else {
1112 readStream->alloc(
1113 (void**)&pBufferMemoryBarriers,
1114 ((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
1115 }
1116 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
1117 reservedunmarshal_VkBufferMemoryBarrier(
1118 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1119 (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i), readStreamPtrPtr);
1120 }
1121 memcpy((uint32_t*)&imageMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1122 *readStreamPtrPtr += sizeof(uint32_t);
1123 if (((imageMemoryBarrierCount)) <= MAX_STACK_ITEMS) {
1124 pImageMemoryBarriers = (VkImageMemoryBarrier*)stack_pImageMemoryBarriers;
1125 } else {
1126 readStream->alloc(
1127 (void**)&pImageMemoryBarriers,
1128 ((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
1129 }
1130 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
1131 reservedunmarshal_VkImageMemoryBarrier(
1132 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1133 (VkImageMemoryBarrier*)(pImageMemoryBarriers + i), readStreamPtrPtr);
1134 }
1135 if (pMemoryBarriers) {
1136 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
1137 transform_tohost_VkMemoryBarrier(globalstate,
1138 (VkMemoryBarrier*)(pMemoryBarriers + i));
1139 }
1140 }
1141 if (pBufferMemoryBarriers) {
1142 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
1143 transform_tohost_VkBufferMemoryBarrier(
1144 globalstate, (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i));
1145 }
1146 }
1147 if (pImageMemoryBarriers) {
1148 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
1149 transform_tohost_VkImageMemoryBarrier(
1150 globalstate, (VkImageMemoryBarrier*)(pImageMemoryBarriers + i));
1151 }
1152 }
1153 if (CC_LIKELY(vk)) {
1154 vk->vkCmdWaitEvents(
1155 (VkCommandBuffer)dispatchHandle, eventCount, pEvents, srcStageMask,
1156 dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
1157 pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1158 }
1159 break;
1160 }
1161 case OP_vkCmdPipelineBarrier: {
1162 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1163 "VkSubDecoder vkCmdPipelineBarrier");
1164 VkPipelineStageFlags srcStageMask;
1165 VkPipelineStageFlags dstStageMask;
1166 VkDependencyFlags dependencyFlags;
1167 uint32_t memoryBarrierCount;
1168 const VkMemoryBarrier* pMemoryBarriers;
1169 VkMemoryBarrier stack_pMemoryBarriers[MAX_STACK_ITEMS];
1170 uint32_t bufferMemoryBarrierCount;
1171 const VkBufferMemoryBarrier* pBufferMemoryBarriers;
1172 VkBufferMemoryBarrier stack_pBufferMemoryBarriers[MAX_STACK_ITEMS];
1173 uint32_t imageMemoryBarrierCount;
1174 const VkImageMemoryBarrier* pImageMemoryBarriers;
1175 VkImageMemoryBarrier stack_pImageMemoryBarriers[MAX_STACK_ITEMS];
1176 memcpy((VkPipelineStageFlags*)&srcStageMask, *readStreamPtrPtr,
1177 sizeof(VkPipelineStageFlags));
1178 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1179 memcpy((VkPipelineStageFlags*)&dstStageMask, *readStreamPtrPtr,
1180 sizeof(VkPipelineStageFlags));
1181 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1182 memcpy((VkDependencyFlags*)&dependencyFlags, *readStreamPtrPtr,
1183 sizeof(VkDependencyFlags));
1184 *readStreamPtrPtr += sizeof(VkDependencyFlags);
1185 memcpy((uint32_t*)&memoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1186 *readStreamPtrPtr += sizeof(uint32_t);
1187 if (((memoryBarrierCount)) <= MAX_STACK_ITEMS) {
1188 pMemoryBarriers = (VkMemoryBarrier*)stack_pMemoryBarriers;
1189 } else {
1190 readStream->alloc((void**)&pMemoryBarriers,
1191 ((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
1192 }
1193 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
1194 reservedunmarshal_VkMemoryBarrier(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1195 (VkMemoryBarrier*)(pMemoryBarriers + i),
1196 readStreamPtrPtr);
1197 }
1198 memcpy((uint32_t*)&bufferMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1199 *readStreamPtrPtr += sizeof(uint32_t);
1200 if (((bufferMemoryBarrierCount)) <= MAX_STACK_ITEMS) {
1201 pBufferMemoryBarriers = (VkBufferMemoryBarrier*)stack_pBufferMemoryBarriers;
1202 } else {
1203 readStream->alloc(
1204 (void**)&pBufferMemoryBarriers,
1205 ((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
1206 }
1207 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
1208 reservedunmarshal_VkBufferMemoryBarrier(
1209 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1210 (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i), readStreamPtrPtr);
1211 }
1212 memcpy((uint32_t*)&imageMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1213 *readStreamPtrPtr += sizeof(uint32_t);
1214 if (((imageMemoryBarrierCount)) <= MAX_STACK_ITEMS) {
1215 pImageMemoryBarriers = (VkImageMemoryBarrier*)stack_pImageMemoryBarriers;
1216 } else {
1217 readStream->alloc(
1218 (void**)&pImageMemoryBarriers,
1219 ((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
1220 }
1221 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
1222 reservedunmarshal_VkImageMemoryBarrier(
1223 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1224 (VkImageMemoryBarrier*)(pImageMemoryBarriers + i), readStreamPtrPtr);
1225 }
1226 if (pMemoryBarriers) {
1227 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
1228 transform_tohost_VkMemoryBarrier(globalstate,
1229 (VkMemoryBarrier*)(pMemoryBarriers + i));
1230 }
1231 }
1232 if (pBufferMemoryBarriers) {
1233 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
1234 transform_tohost_VkBufferMemoryBarrier(
1235 globalstate, (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i));
1236 }
1237 }
1238 if (pImageMemoryBarriers) {
1239 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
1240 transform_tohost_VkImageMemoryBarrier(
1241 globalstate, (VkImageMemoryBarrier*)(pImageMemoryBarriers + i));
1242 }
1243 }
1244 if (CC_LIKELY(vk)) {
1245 this->on_vkCmdPipelineBarrier(
1246 pool, nullptr, (VkCommandBuffer)(boxed_dispatchHandle), srcStageMask,
1247 dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers,
1248 bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount,
1249 pImageMemoryBarriers);
1250 }
1251 break;
1252 }
1253 case OP_vkCmdBeginQuery: {
1254 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1255 "VkSubDecoder vkCmdBeginQuery");
1256 VkQueryPool queryPool;
1257 uint32_t query;
1258 VkQueryControlFlags flags;
1259 uint64_t cgen_var_0;
1260 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1261 *readStreamPtrPtr += 1 * 8;
1262 *(VkQueryPool*)&queryPool =
1263 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1264 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
1265 *readStreamPtrPtr += sizeof(uint32_t);
1266 memcpy((VkQueryControlFlags*)&flags, *readStreamPtrPtr,
1267 sizeof(VkQueryControlFlags));
1268 *readStreamPtrPtr += sizeof(VkQueryControlFlags);
1269 if (CC_LIKELY(vk)) {
1270 vk->vkCmdBeginQuery((VkCommandBuffer)dispatchHandle, queryPool, query, flags);
1271 }
1272 break;
1273 }
1274 case OP_vkCmdEndQuery: {
1275 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1276 "VkSubDecoder vkCmdEndQuery");
1277 VkQueryPool queryPool;
1278 uint32_t query;
1279 uint64_t cgen_var_0;
1280 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1281 *readStreamPtrPtr += 1 * 8;
1282 *(VkQueryPool*)&queryPool =
1283 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1284 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
1285 *readStreamPtrPtr += sizeof(uint32_t);
1286 if (CC_LIKELY(vk)) {
1287 vk->vkCmdEndQuery((VkCommandBuffer)dispatchHandle, queryPool, query);
1288 }
1289 break;
1290 }
1291 case OP_vkCmdResetQueryPool: {
1292 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1293 "VkSubDecoder vkCmdResetQueryPool");
1294 VkQueryPool queryPool;
1295 uint32_t firstQuery;
1296 uint32_t queryCount;
1297 uint64_t cgen_var_0;
1298 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1299 *readStreamPtrPtr += 1 * 8;
1300 *(VkQueryPool*)&queryPool =
1301 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1302 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
1303 *readStreamPtrPtr += sizeof(uint32_t);
1304 memcpy((uint32_t*)&queryCount, *readStreamPtrPtr, sizeof(uint32_t));
1305 *readStreamPtrPtr += sizeof(uint32_t);
1306 if (CC_LIKELY(vk)) {
1307 vk->vkCmdResetQueryPool((VkCommandBuffer)dispatchHandle, queryPool, firstQuery,
1308 queryCount);
1309 }
1310 break;
1311 }
1312 case OP_vkCmdWriteTimestamp: {
1313 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1314 "VkSubDecoder vkCmdWriteTimestamp");
1315 VkPipelineStageFlagBits pipelineStage;
1316 VkQueryPool queryPool;
1317 uint32_t query;
1318 memcpy((VkPipelineStageFlagBits*)&pipelineStage, *readStreamPtrPtr,
1319 sizeof(VkPipelineStageFlagBits));
1320 *readStreamPtrPtr += sizeof(VkPipelineStageFlagBits);
1321 uint64_t cgen_var_0;
1322 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1323 *readStreamPtrPtr += 1 * 8;
1324 *(VkQueryPool*)&queryPool =
1325 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1326 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
1327 *readStreamPtrPtr += sizeof(uint32_t);
1328 if (CC_LIKELY(vk)) {
1329 vk->vkCmdWriteTimestamp((VkCommandBuffer)dispatchHandle, pipelineStage,
1330 queryPool, query);
1331 }
1332 break;
1333 }
1334 case OP_vkCmdCopyQueryPoolResults: {
1335 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1336 "VkSubDecoder vkCmdCopyQueryPoolResults");
1337 VkQueryPool queryPool;
1338 uint32_t firstQuery;
1339 uint32_t queryCount;
1340 VkBuffer dstBuffer;
1341 VkDeviceSize dstOffset;
1342 VkDeviceSize stride;
1343 VkQueryResultFlags flags;
1344 uint64_t cgen_var_0;
1345 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1346 *readStreamPtrPtr += 1 * 8;
1347 *(VkQueryPool*)&queryPool =
1348 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1349 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
1350 *readStreamPtrPtr += sizeof(uint32_t);
1351 memcpy((uint32_t*)&queryCount, *readStreamPtrPtr, sizeof(uint32_t));
1352 *readStreamPtrPtr += sizeof(uint32_t);
1353 uint64_t cgen_var_1;
1354 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1355 *readStreamPtrPtr += 1 * 8;
1356 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
1357 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1358 *readStreamPtrPtr += sizeof(VkDeviceSize);
1359 memcpy((VkDeviceSize*)&stride, *readStreamPtrPtr, sizeof(VkDeviceSize));
1360 *readStreamPtrPtr += sizeof(VkDeviceSize);
1361 memcpy((VkQueryResultFlags*)&flags, *readStreamPtrPtr, sizeof(VkQueryResultFlags));
1362 *readStreamPtrPtr += sizeof(VkQueryResultFlags);
1363 if (CC_LIKELY(vk)) {
1364 this->on_vkCmdCopyQueryPoolResults(
1365 pool, nullptr, (VkCommandBuffer)(boxed_dispatchHandle), queryPool,
1366 firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
1367 }
1368 break;
1369 }
1370 case OP_vkCmdPushConstants: {
1371 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1372 "VkSubDecoder vkCmdPushConstants");
1373 VkPipelineLayout layout;
1374 VkShaderStageFlags stageFlags;
1375 uint32_t offset;
1376 uint32_t size;
1377 const void* pValues;
1378 uint8_t* stack_pValues[MAX_STACK_ITEMS];
1379 uint64_t cgen_var_0;
1380 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1381 *readStreamPtrPtr += 1 * 8;
1382 *(VkPipelineLayout*)&layout =
1383 (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
1384 memcpy((VkShaderStageFlags*)&stageFlags, *readStreamPtrPtr,
1385 sizeof(VkShaderStageFlags));
1386 *readStreamPtrPtr += sizeof(VkShaderStageFlags);
1387 memcpy((uint32_t*)&offset, *readStreamPtrPtr, sizeof(uint32_t));
1388 *readStreamPtrPtr += sizeof(uint32_t);
1389 memcpy((uint32_t*)&size, *readStreamPtrPtr, sizeof(uint32_t));
1390 *readStreamPtrPtr += sizeof(uint32_t);
1391 if (((size)) <= MAX_STACK_ITEMS) {
1392 pValues = (void*)stack_pValues;
1393 } else {
1394 readStream->alloc((void**)&pValues, ((size)) * sizeof(const uint8_t));
1395 }
1396 memcpy((void*)pValues, *readStreamPtrPtr, ((size)) * sizeof(const uint8_t));
1397 *readStreamPtrPtr += ((size)) * sizeof(const uint8_t);
1398 if (CC_LIKELY(vk)) {
1399 vk->vkCmdPushConstants((VkCommandBuffer)dispatchHandle, layout, stageFlags,
1400 offset, size, pValues);
1401 }
1402 break;
1403 }
1404 case OP_vkCmdBeginRenderPass: {
1405 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1406 "VkSubDecoder vkCmdBeginRenderPass");
1407 const VkRenderPassBeginInfo* pRenderPassBegin;
1408 VkRenderPassBeginInfo stack_pRenderPassBegin[1];
1409 VkSubpassContents contents;
1410 pRenderPassBegin = (VkRenderPassBeginInfo*)stack_pRenderPassBegin;
1411 reservedunmarshal_VkRenderPassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1412 (VkRenderPassBeginInfo*)(pRenderPassBegin),
1413 readStreamPtrPtr);
1414 memcpy((VkSubpassContents*)&contents, *readStreamPtrPtr, sizeof(VkSubpassContents));
1415 *readStreamPtrPtr += sizeof(VkSubpassContents);
1416 if (pRenderPassBegin) {
1417 transform_tohost_VkRenderPassBeginInfo(
1418 globalstate, (VkRenderPassBeginInfo*)(pRenderPassBegin));
1419 }
1420 if (CC_LIKELY(vk)) {
1421 this->on_vkCmdBeginRenderPass(pool, nullptr,
1422 (VkCommandBuffer)(boxed_dispatchHandle),
1423 pRenderPassBegin, contents);
1424 }
1425 break;
1426 }
1427 case OP_vkCmdNextSubpass: {
1428 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1429 "VkSubDecoder vkCmdNextSubpass");
1430 VkSubpassContents contents;
1431 memcpy((VkSubpassContents*)&contents, *readStreamPtrPtr, sizeof(VkSubpassContents));
1432 *readStreamPtrPtr += sizeof(VkSubpassContents);
1433 if (CC_LIKELY(vk)) {
1434 vk->vkCmdNextSubpass((VkCommandBuffer)dispatchHandle, contents);
1435 }
1436 break;
1437 }
1438 case OP_vkCmdEndRenderPass: {
1439 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1440 "VkSubDecoder vkCmdEndRenderPass");
1441 if (CC_LIKELY(vk)) {
1442 vk->vkCmdEndRenderPass((VkCommandBuffer)dispatchHandle);
1443 }
1444 break;
1445 }
1446 case OP_vkCmdExecuteCommands: {
1447 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1448 "VkSubDecoder vkCmdExecuteCommands");
1449 uint32_t commandBufferCount;
1450 const VkCommandBuffer* pCommandBuffers;
1451 VkCommandBuffer stack_pCommandBuffers[MAX_STACK_ITEMS];
1452 memcpy((uint32_t*)&commandBufferCount, *readStreamPtrPtr, sizeof(uint32_t));
1453 *readStreamPtrPtr += sizeof(uint32_t);
1454 if (((commandBufferCount)) <= MAX_STACK_ITEMS) {
1455 pCommandBuffers = (VkCommandBuffer*)stack_pCommandBuffers;
1456 } else {
1457 readStream->alloc((void**)&pCommandBuffers,
1458 ((commandBufferCount)) * sizeof(const VkCommandBuffer));
1459 }
1460 if (((commandBufferCount))) {
1461 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
1462 *readStreamPtrPtr += 8 * ((commandBufferCount));
1463 for (uint32_t k = 0; k < ((commandBufferCount)); ++k) {
1464 uint64_t tmpval;
1465 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
1466 *(((VkCommandBuffer*)pCommandBuffers) + k) =
1467 tmpval ? (VkCommandBuffer)unbox_VkCommandBuffer((VkCommandBuffer)tmpval)
1468 : VK_NULL_HANDLE;
1469 }
1470 }
1471 if (CC_LIKELY(vk)) {
1472 this->on_vkCmdExecuteCommands(pool, nullptr,
1473 (VkCommandBuffer)(boxed_dispatchHandle),
1474 commandBufferCount, pCommandBuffers);
1475 }
1476 break;
1477 }
1478 #endif
1479 #ifdef VK_VERSION_1_1
1480 case OP_vkCmdSetDeviceMask: {
1481 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1482 "VkSubDecoder vkCmdSetDeviceMask");
1483 uint32_t deviceMask;
1484 memcpy((uint32_t*)&deviceMask, *readStreamPtrPtr, sizeof(uint32_t));
1485 *readStreamPtrPtr += sizeof(uint32_t);
1486 if (CC_LIKELY(vk)) {
1487 vk->vkCmdSetDeviceMask((VkCommandBuffer)dispatchHandle, deviceMask);
1488 }
1489 break;
1490 }
1491 case OP_vkCmdDispatchBase: {
1492 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1493 "VkSubDecoder vkCmdDispatchBase");
1494 uint32_t baseGroupX;
1495 uint32_t baseGroupY;
1496 uint32_t baseGroupZ;
1497 uint32_t groupCountX;
1498 uint32_t groupCountY;
1499 uint32_t groupCountZ;
1500 memcpy((uint32_t*)&baseGroupX, *readStreamPtrPtr, sizeof(uint32_t));
1501 *readStreamPtrPtr += sizeof(uint32_t);
1502 memcpy((uint32_t*)&baseGroupY, *readStreamPtrPtr, sizeof(uint32_t));
1503 *readStreamPtrPtr += sizeof(uint32_t);
1504 memcpy((uint32_t*)&baseGroupZ, *readStreamPtrPtr, sizeof(uint32_t));
1505 *readStreamPtrPtr += sizeof(uint32_t);
1506 memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
1507 *readStreamPtrPtr += sizeof(uint32_t);
1508 memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
1509 *readStreamPtrPtr += sizeof(uint32_t);
1510 memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
1511 *readStreamPtrPtr += sizeof(uint32_t);
1512 if (CC_LIKELY(vk)) {
1513 vk->vkCmdDispatchBase((VkCommandBuffer)dispatchHandle, baseGroupX, baseGroupY,
1514 baseGroupZ, groupCountX, groupCountY, groupCountZ);
1515 }
1516 break;
1517 }
1518 #endif
1519 #ifdef VK_VERSION_1_2
1520 case OP_vkCmdDrawIndirectCount: {
1521 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1522 "VkSubDecoder vkCmdDrawIndirectCount");
1523 VkBuffer buffer;
1524 VkDeviceSize offset;
1525 VkBuffer countBuffer;
1526 VkDeviceSize countBufferOffset;
1527 uint32_t maxDrawCount;
1528 uint32_t stride;
1529 uint64_t cgen_var_0;
1530 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1531 *readStreamPtrPtr += 1 * 8;
1532 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
1533 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1534 *readStreamPtrPtr += sizeof(VkDeviceSize);
1535 uint64_t cgen_var_1;
1536 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1537 *readStreamPtrPtr += 1 * 8;
1538 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
1539 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1540 *readStreamPtrPtr += sizeof(VkDeviceSize);
1541 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
1542 *readStreamPtrPtr += sizeof(uint32_t);
1543 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
1544 *readStreamPtrPtr += sizeof(uint32_t);
1545 if (CC_LIKELY(vk)) {
1546 vk->vkCmdDrawIndirectCount((VkCommandBuffer)dispatchHandle, buffer, offset,
1547 countBuffer, countBufferOffset, maxDrawCount,
1548 stride);
1549 }
1550 break;
1551 }
1552 case OP_vkCmdDrawIndexedIndirectCount: {
1553 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1554 "VkSubDecoder vkCmdDrawIndexedIndirectCount");
1555 VkBuffer buffer;
1556 VkDeviceSize offset;
1557 VkBuffer countBuffer;
1558 VkDeviceSize countBufferOffset;
1559 uint32_t maxDrawCount;
1560 uint32_t stride;
1561 uint64_t cgen_var_0;
1562 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1563 *readStreamPtrPtr += 1 * 8;
1564 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
1565 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1566 *readStreamPtrPtr += sizeof(VkDeviceSize);
1567 uint64_t cgen_var_1;
1568 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1569 *readStreamPtrPtr += 1 * 8;
1570 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
1571 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1572 *readStreamPtrPtr += sizeof(VkDeviceSize);
1573 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
1574 *readStreamPtrPtr += sizeof(uint32_t);
1575 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
1576 *readStreamPtrPtr += sizeof(uint32_t);
1577 if (CC_LIKELY(vk)) {
1578 vk->vkCmdDrawIndexedIndirectCount((VkCommandBuffer)dispatchHandle, buffer,
1579 offset, countBuffer, countBufferOffset,
1580 maxDrawCount, stride);
1581 }
1582 break;
1583 }
1584 case OP_vkCmdBeginRenderPass2: {
1585 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1586 "VkSubDecoder vkCmdBeginRenderPass2");
1587 const VkRenderPassBeginInfo* pRenderPassBegin;
1588 VkRenderPassBeginInfo stack_pRenderPassBegin[1];
1589 const VkSubpassBeginInfo* pSubpassBeginInfo;
1590 VkSubpassBeginInfo stack_pSubpassBeginInfo[1];
1591 pRenderPassBegin = (VkRenderPassBeginInfo*)stack_pRenderPassBegin;
1592 reservedunmarshal_VkRenderPassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1593 (VkRenderPassBeginInfo*)(pRenderPassBegin),
1594 readStreamPtrPtr);
1595 pSubpassBeginInfo = (VkSubpassBeginInfo*)stack_pSubpassBeginInfo;
1596 reservedunmarshal_VkSubpassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1597 (VkSubpassBeginInfo*)(pSubpassBeginInfo),
1598 readStreamPtrPtr);
1599 if (pRenderPassBegin) {
1600 transform_tohost_VkRenderPassBeginInfo(
1601 globalstate, (VkRenderPassBeginInfo*)(pRenderPassBegin));
1602 }
1603 if (pSubpassBeginInfo) {
1604 transform_tohost_VkSubpassBeginInfo(globalstate,
1605 (VkSubpassBeginInfo*)(pSubpassBeginInfo));
1606 }
1607 if (CC_LIKELY(vk)) {
1608 this->on_vkCmdBeginRenderPass2(pool, nullptr,
1609 (VkCommandBuffer)(boxed_dispatchHandle),
1610 pRenderPassBegin, pSubpassBeginInfo);
1611 }
1612 break;
1613 }
1614 case OP_vkCmdNextSubpass2: {
1615 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1616 "VkSubDecoder vkCmdNextSubpass2");
1617 const VkSubpassBeginInfo* pSubpassBeginInfo;
1618 VkSubpassBeginInfo stack_pSubpassBeginInfo[1];
1619 const VkSubpassEndInfo* pSubpassEndInfo;
1620 VkSubpassEndInfo stack_pSubpassEndInfo[1];
1621 pSubpassBeginInfo = (VkSubpassBeginInfo*)stack_pSubpassBeginInfo;
1622 reservedunmarshal_VkSubpassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1623 (VkSubpassBeginInfo*)(pSubpassBeginInfo),
1624 readStreamPtrPtr);
1625 pSubpassEndInfo = (VkSubpassEndInfo*)stack_pSubpassEndInfo;
1626 reservedunmarshal_VkSubpassEndInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1627 (VkSubpassEndInfo*)(pSubpassEndInfo),
1628 readStreamPtrPtr);
1629 if (pSubpassBeginInfo) {
1630 transform_tohost_VkSubpassBeginInfo(globalstate,
1631 (VkSubpassBeginInfo*)(pSubpassBeginInfo));
1632 }
1633 if (pSubpassEndInfo) {
1634 transform_tohost_VkSubpassEndInfo(globalstate,
1635 (VkSubpassEndInfo*)(pSubpassEndInfo));
1636 }
1637 if (CC_LIKELY(vk)) {
1638 vk->vkCmdNextSubpass2((VkCommandBuffer)dispatchHandle, pSubpassBeginInfo,
1639 pSubpassEndInfo);
1640 }
1641 break;
1642 }
1643 case OP_vkCmdEndRenderPass2: {
1644 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1645 "VkSubDecoder vkCmdEndRenderPass2");
1646 const VkSubpassEndInfo* pSubpassEndInfo;
1647 VkSubpassEndInfo stack_pSubpassEndInfo[1];
1648 pSubpassEndInfo = (VkSubpassEndInfo*)stack_pSubpassEndInfo;
1649 reservedunmarshal_VkSubpassEndInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1650 (VkSubpassEndInfo*)(pSubpassEndInfo),
1651 readStreamPtrPtr);
1652 if (pSubpassEndInfo) {
1653 transform_tohost_VkSubpassEndInfo(globalstate,
1654 (VkSubpassEndInfo*)(pSubpassEndInfo));
1655 }
1656 if (CC_LIKELY(vk)) {
1657 vk->vkCmdEndRenderPass2((VkCommandBuffer)dispatchHandle, pSubpassEndInfo);
1658 }
1659 break;
1660 }
1661 #endif
1662 #ifdef VK_VERSION_1_3
1663 case OP_vkCmdSetEvent2: {
1664 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1665 "VkSubDecoder vkCmdSetEvent2");
1666 VkEvent event;
1667 const VkDependencyInfo* pDependencyInfo;
1668 VkDependencyInfo stack_pDependencyInfo[1];
1669 uint64_t cgen_var_0;
1670 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1671 *readStreamPtrPtr += 1 * 8;
1672 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
1673 pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
1674 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1675 (VkDependencyInfo*)(pDependencyInfo),
1676 readStreamPtrPtr);
1677 if (pDependencyInfo) {
1678 transform_tohost_VkDependencyInfo(globalstate,
1679 (VkDependencyInfo*)(pDependencyInfo));
1680 }
1681 if (CC_LIKELY(vk)) {
1682 vk->vkCmdSetEvent2((VkCommandBuffer)dispatchHandle, event, pDependencyInfo);
1683 }
1684 break;
1685 }
1686 case OP_vkCmdResetEvent2: {
1687 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1688 "VkSubDecoder vkCmdResetEvent2");
1689 VkEvent event;
1690 VkPipelineStageFlags2 stageMask;
1691 uint64_t cgen_var_0;
1692 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1693 *readStreamPtrPtr += 1 * 8;
1694 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
1695 memcpy((VkPipelineStageFlags2*)&stageMask, *readStreamPtrPtr,
1696 sizeof(VkPipelineStageFlags2));
1697 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
1698 if (CC_LIKELY(vk)) {
1699 vk->vkCmdResetEvent2((VkCommandBuffer)dispatchHandle, event, stageMask);
1700 }
1701 break;
1702 }
1703 case OP_vkCmdWaitEvents2: {
1704 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1705 "VkSubDecoder vkCmdWaitEvents2");
1706 uint32_t eventCount;
1707 const VkEvent* pEvents;
1708 VkEvent stack_pEvents[MAX_STACK_ITEMS];
1709 const VkDependencyInfo* pDependencyInfos;
1710 VkDependencyInfo stack_pDependencyInfos[MAX_STACK_ITEMS];
1711 memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
1712 *readStreamPtrPtr += sizeof(uint32_t);
1713 if (((eventCount)) <= MAX_STACK_ITEMS) {
1714 pEvents = (VkEvent*)stack_pEvents;
1715 } else {
1716 readStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
1717 }
1718 if (((eventCount))) {
1719 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
1720 *readStreamPtrPtr += 8 * ((eventCount));
1721 for (uint32_t k = 0; k < ((eventCount)); ++k) {
1722 uint64_t tmpval;
1723 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
1724 *(((VkEvent*)pEvents) + k) =
1725 tmpval ? (VkEvent)unbox_VkEvent((VkEvent)tmpval) : VK_NULL_HANDLE;
1726 }
1727 }
1728 if (((eventCount)) <= MAX_STACK_ITEMS) {
1729 pDependencyInfos = (VkDependencyInfo*)stack_pDependencyInfos;
1730 } else {
1731 readStream->alloc((void**)&pDependencyInfos,
1732 ((eventCount)) * sizeof(const VkDependencyInfo));
1733 }
1734 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
1735 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1736 (VkDependencyInfo*)(pDependencyInfos + i),
1737 readStreamPtrPtr);
1738 }
1739 if (pDependencyInfos) {
1740 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
1741 transform_tohost_VkDependencyInfo(
1742 globalstate, (VkDependencyInfo*)(pDependencyInfos + i));
1743 }
1744 }
1745 if (CC_LIKELY(vk)) {
1746 vk->vkCmdWaitEvents2((VkCommandBuffer)dispatchHandle, eventCount, pEvents,
1747 pDependencyInfos);
1748 }
1749 break;
1750 }
1751 case OP_vkCmdPipelineBarrier2: {
1752 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1753 "VkSubDecoder vkCmdPipelineBarrier2");
1754 const VkDependencyInfo* pDependencyInfo;
1755 VkDependencyInfo stack_pDependencyInfo[1];
1756 pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
1757 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1758 (VkDependencyInfo*)(pDependencyInfo),
1759 readStreamPtrPtr);
1760 if (pDependencyInfo) {
1761 transform_tohost_VkDependencyInfo(globalstate,
1762 (VkDependencyInfo*)(pDependencyInfo));
1763 }
1764 if (CC_LIKELY(vk)) {
1765 this->on_vkCmdPipelineBarrier2(
1766 pool, nullptr, (VkCommandBuffer)(boxed_dispatchHandle), pDependencyInfo);
1767 }
1768 break;
1769 }
1770 case OP_vkCmdWriteTimestamp2: {
1771 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1772 "VkSubDecoder vkCmdWriteTimestamp2");
1773 VkPipelineStageFlags2 stage;
1774 VkQueryPool queryPool;
1775 uint32_t query;
1776 memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
1777 sizeof(VkPipelineStageFlags2));
1778 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
1779 uint64_t cgen_var_0;
1780 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1781 *readStreamPtrPtr += 1 * 8;
1782 *(VkQueryPool*)&queryPool =
1783 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1784 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
1785 *readStreamPtrPtr += sizeof(uint32_t);
1786 if (CC_LIKELY(vk)) {
1787 vk->vkCmdWriteTimestamp2((VkCommandBuffer)dispatchHandle, stage, queryPool,
1788 query);
1789 }
1790 break;
1791 }
1792 case OP_vkCmdCopyBuffer2: {
1793 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1794 "VkSubDecoder vkCmdCopyBuffer2");
1795 const VkCopyBufferInfo2* pCopyBufferInfo;
1796 VkCopyBufferInfo2 stack_pCopyBufferInfo[1];
1797 pCopyBufferInfo = (VkCopyBufferInfo2*)stack_pCopyBufferInfo;
1798 reservedunmarshal_VkCopyBufferInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1799 (VkCopyBufferInfo2*)(pCopyBufferInfo),
1800 readStreamPtrPtr);
1801 if (pCopyBufferInfo) {
1802 transform_tohost_VkCopyBufferInfo2(globalstate,
1803 (VkCopyBufferInfo2*)(pCopyBufferInfo));
1804 }
1805 if (CC_LIKELY(vk)) {
1806 vk->vkCmdCopyBuffer2((VkCommandBuffer)dispatchHandle, pCopyBufferInfo);
1807 }
1808 break;
1809 }
1810 case OP_vkCmdCopyImage2: {
1811 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1812 "VkSubDecoder vkCmdCopyImage2");
1813 const VkCopyImageInfo2* pCopyImageInfo;
1814 VkCopyImageInfo2 stack_pCopyImageInfo[1];
1815 pCopyImageInfo = (VkCopyImageInfo2*)stack_pCopyImageInfo;
1816 reservedunmarshal_VkCopyImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1817 (VkCopyImageInfo2*)(pCopyImageInfo),
1818 readStreamPtrPtr);
1819 if (pCopyImageInfo) {
1820 transform_tohost_VkCopyImageInfo2(globalstate,
1821 (VkCopyImageInfo2*)(pCopyImageInfo));
1822 }
1823 if (CC_LIKELY(vk)) {
1824 this->on_vkCmdCopyImage2(pool, nullptr, (VkCommandBuffer)(boxed_dispatchHandle),
1825 pCopyImageInfo);
1826 }
1827 break;
1828 }
1829 case OP_vkCmdCopyBufferToImage2: {
1830 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1831 "VkSubDecoder vkCmdCopyBufferToImage2");
1832 const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo;
1833 VkCopyBufferToImageInfo2 stack_pCopyBufferToImageInfo[1];
1834 pCopyBufferToImageInfo = (VkCopyBufferToImageInfo2*)stack_pCopyBufferToImageInfo;
1835 reservedunmarshal_VkCopyBufferToImageInfo2(
1836 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1837 (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo), readStreamPtrPtr);
1838 if (pCopyBufferToImageInfo) {
1839 transform_tohost_VkCopyBufferToImageInfo2(
1840 globalstate, (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo));
1841 }
1842 if (CC_LIKELY(vk)) {
1843 this->on_vkCmdCopyBufferToImage2(pool, nullptr,
1844 (VkCommandBuffer)(boxed_dispatchHandle),
1845 pCopyBufferToImageInfo, context);
1846 }
1847 break;
1848 }
1849 case OP_vkCmdCopyImageToBuffer2: {
1850 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1851 "VkSubDecoder vkCmdCopyImageToBuffer2");
1852 const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo;
1853 VkCopyImageToBufferInfo2 stack_pCopyImageToBufferInfo[1];
1854 pCopyImageToBufferInfo = (VkCopyImageToBufferInfo2*)stack_pCopyImageToBufferInfo;
1855 reservedunmarshal_VkCopyImageToBufferInfo2(
1856 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1857 (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo), readStreamPtrPtr);
1858 if (pCopyImageToBufferInfo) {
1859 transform_tohost_VkCopyImageToBufferInfo2(
1860 globalstate, (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo));
1861 }
1862 if (CC_LIKELY(vk)) {
1863 this->on_vkCmdCopyImageToBuffer2(pool, nullptr,
1864 (VkCommandBuffer)(boxed_dispatchHandle),
1865 pCopyImageToBufferInfo);
1866 }
1867 break;
1868 }
1869 case OP_vkCmdBlitImage2: {
1870 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1871 "VkSubDecoder vkCmdBlitImage2");
1872 const VkBlitImageInfo2* pBlitImageInfo;
1873 VkBlitImageInfo2 stack_pBlitImageInfo[1];
1874 pBlitImageInfo = (VkBlitImageInfo2*)stack_pBlitImageInfo;
1875 reservedunmarshal_VkBlitImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1876 (VkBlitImageInfo2*)(pBlitImageInfo),
1877 readStreamPtrPtr);
1878 if (pBlitImageInfo) {
1879 transform_tohost_VkBlitImageInfo2(globalstate,
1880 (VkBlitImageInfo2*)(pBlitImageInfo));
1881 }
1882 if (CC_LIKELY(vk)) {
1883 vk->vkCmdBlitImage2((VkCommandBuffer)dispatchHandle, pBlitImageInfo);
1884 }
1885 break;
1886 }
1887 case OP_vkCmdResolveImage2: {
1888 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1889 "VkSubDecoder vkCmdResolveImage2");
1890 const VkResolveImageInfo2* pResolveImageInfo;
1891 VkResolveImageInfo2 stack_pResolveImageInfo[1];
1892 pResolveImageInfo = (VkResolveImageInfo2*)stack_pResolveImageInfo;
1893 reservedunmarshal_VkResolveImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1894 (VkResolveImageInfo2*)(pResolveImageInfo),
1895 readStreamPtrPtr);
1896 if (pResolveImageInfo) {
1897 transform_tohost_VkResolveImageInfo2(globalstate,
1898 (VkResolveImageInfo2*)(pResolveImageInfo));
1899 }
1900 if (CC_LIKELY(vk)) {
1901 vk->vkCmdResolveImage2((VkCommandBuffer)dispatchHandle, pResolveImageInfo);
1902 }
1903 break;
1904 }
1905 case OP_vkCmdBeginRendering: {
1906 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1907 "VkSubDecoder vkCmdBeginRendering");
1908 const VkRenderingInfo* pRenderingInfo;
1909 VkRenderingInfo stack_pRenderingInfo[1];
1910 pRenderingInfo = (VkRenderingInfo*)stack_pRenderingInfo;
1911 reservedunmarshal_VkRenderingInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1912 (VkRenderingInfo*)(pRenderingInfo),
1913 readStreamPtrPtr);
1914 if (pRenderingInfo) {
1915 transform_tohost_VkRenderingInfo(globalstate,
1916 (VkRenderingInfo*)(pRenderingInfo));
1917 }
1918 if (CC_LIKELY(vk)) {
1919 vk->vkCmdBeginRendering((VkCommandBuffer)dispatchHandle, pRenderingInfo);
1920 }
1921 break;
1922 }
1923 case OP_vkCmdEndRendering: {
1924 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1925 "VkSubDecoder vkCmdEndRendering");
1926 if (CC_LIKELY(vk)) {
1927 vk->vkCmdEndRendering((VkCommandBuffer)dispatchHandle);
1928 }
1929 break;
1930 }
1931 case OP_vkCmdSetCullMode: {
1932 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1933 "VkSubDecoder vkCmdSetCullMode");
1934 VkCullModeFlags cullMode;
1935 memcpy((VkCullModeFlags*)&cullMode, *readStreamPtrPtr, sizeof(VkCullModeFlags));
1936 *readStreamPtrPtr += sizeof(VkCullModeFlags);
1937 if (CC_LIKELY(vk)) {
1938 vk->vkCmdSetCullMode((VkCommandBuffer)dispatchHandle, cullMode);
1939 }
1940 break;
1941 }
1942 case OP_vkCmdSetFrontFace: {
1943 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1944 "VkSubDecoder vkCmdSetFrontFace");
1945 VkFrontFace frontFace;
1946 memcpy((VkFrontFace*)&frontFace, *readStreamPtrPtr, sizeof(VkFrontFace));
1947 *readStreamPtrPtr += sizeof(VkFrontFace);
1948 if (CC_LIKELY(vk)) {
1949 vk->vkCmdSetFrontFace((VkCommandBuffer)dispatchHandle, frontFace);
1950 }
1951 break;
1952 }
1953 case OP_vkCmdSetPrimitiveTopology: {
1954 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1955 "VkSubDecoder vkCmdSetPrimitiveTopology");
1956 VkPrimitiveTopology primitiveTopology;
1957 memcpy((VkPrimitiveTopology*)&primitiveTopology, *readStreamPtrPtr,
1958 sizeof(VkPrimitiveTopology));
1959 *readStreamPtrPtr += sizeof(VkPrimitiveTopology);
1960 if (CC_LIKELY(vk)) {
1961 vk->vkCmdSetPrimitiveTopology((VkCommandBuffer)dispatchHandle,
1962 primitiveTopology);
1963 }
1964 break;
1965 }
1966 case OP_vkCmdSetViewportWithCount: {
1967 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1968 "VkSubDecoder vkCmdSetViewportWithCount");
1969 uint32_t viewportCount;
1970 const VkViewport* pViewports;
1971 VkViewport stack_pViewports[MAX_STACK_ITEMS];
1972 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
1973 *readStreamPtrPtr += sizeof(uint32_t);
1974 if (((viewportCount)) <= MAX_STACK_ITEMS) {
1975 pViewports = (VkViewport*)stack_pViewports;
1976 } else {
1977 readStream->alloc((void**)&pViewports,
1978 ((viewportCount)) * sizeof(const VkViewport));
1979 }
1980 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
1981 reservedunmarshal_VkViewport(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1982 (VkViewport*)(pViewports + i), readStreamPtrPtr);
1983 }
1984 if (pViewports) {
1985 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
1986 transform_tohost_VkViewport(globalstate, (VkViewport*)(pViewports + i));
1987 }
1988 }
1989 if (CC_LIKELY(vk)) {
1990 vk->vkCmdSetViewportWithCount((VkCommandBuffer)dispatchHandle, viewportCount,
1991 pViewports);
1992 }
1993 break;
1994 }
1995 case OP_vkCmdSetScissorWithCount: {
1996 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1997 "VkSubDecoder vkCmdSetScissorWithCount");
1998 uint32_t scissorCount;
1999 const VkRect2D* pScissors;
2000 VkRect2D stack_pScissors[MAX_STACK_ITEMS];
2001 memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
2002 *readStreamPtrPtr += sizeof(uint32_t);
2003 if (((scissorCount)) <= MAX_STACK_ITEMS) {
2004 pScissors = (VkRect2D*)stack_pScissors;
2005 } else {
2006 readStream->alloc((void**)&pScissors,
2007 ((scissorCount)) * sizeof(const VkRect2D));
2008 }
2009 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
2010 reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2011 (VkRect2D*)(pScissors + i), readStreamPtrPtr);
2012 }
2013 if (pScissors) {
2014 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
2015 transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pScissors + i));
2016 }
2017 }
2018 if (CC_LIKELY(vk)) {
2019 vk->vkCmdSetScissorWithCount((VkCommandBuffer)dispatchHandle, scissorCount,
2020 pScissors);
2021 }
2022 break;
2023 }
2024 case OP_vkCmdBindVertexBuffers2: {
2025 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2026 "VkSubDecoder vkCmdBindVertexBuffers2");
2027 uint32_t firstBinding;
2028 uint32_t bindingCount;
2029 const VkBuffer* pBuffers;
2030 VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
2031 const VkDeviceSize* pOffsets;
2032 VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
2033 const VkDeviceSize* pSizes;
2034 VkDeviceSize stack_pSizes[MAX_STACK_ITEMS];
2035 const VkDeviceSize* pStrides;
2036 VkDeviceSize stack_pStrides[MAX_STACK_ITEMS];
2037 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
2038 *readStreamPtrPtr += sizeof(uint32_t);
2039 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
2040 *readStreamPtrPtr += sizeof(uint32_t);
2041 // WARNING PTR CHECK
2042 memcpy((VkBuffer**)&pBuffers, (*readStreamPtrPtr), 8);
2043 android::base::Stream::fromBe64((uint8_t*)&pBuffers);
2044 *readStreamPtrPtr += 8;
2045 if (pBuffers) {
2046 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2047 pBuffers = (VkBuffer*)stack_pBuffers;
2048 } else {
2049 readStream->alloc((void**)&pBuffers,
2050 ((bindingCount)) * sizeof(const VkBuffer));
2051 }
2052 if (((bindingCount))) {
2053 uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2054 *readStreamPtrPtr += 8 * ((bindingCount));
2055 for (uint32_t k = 0; k < ((bindingCount)); ++k) {
2056 uint64_t tmpval;
2057 memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
2058 *(((VkBuffer*)pBuffers) + k) =
2059 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval)
2060 : VK_NULL_HANDLE;
2061 }
2062 }
2063 }
2064 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2065 pOffsets = (VkDeviceSize*)stack_pOffsets;
2066 } else {
2067 readStream->alloc((void**)&pOffsets,
2068 ((bindingCount)) * sizeof(const VkDeviceSize));
2069 }
2070 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
2071 ((bindingCount)) * sizeof(const VkDeviceSize));
2072 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
2073 // WARNING PTR CHECK
2074 memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
2075 android::base::Stream::fromBe64((uint8_t*)&pSizes);
2076 *readStreamPtrPtr += 8;
2077 if (pSizes) {
2078 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2079 pSizes = (VkDeviceSize*)stack_pSizes;
2080 } else {
2081 readStream->alloc((void**)&pSizes,
2082 ((bindingCount)) * sizeof(const VkDeviceSize));
2083 }
2084 memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr,
2085 ((bindingCount)) * sizeof(const VkDeviceSize));
2086 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
2087 }
2088 // WARNING PTR CHECK
2089 memcpy((VkDeviceSize**)&pStrides, (*readStreamPtrPtr), 8);
2090 android::base::Stream::fromBe64((uint8_t*)&pStrides);
2091 *readStreamPtrPtr += 8;
2092 if (pStrides) {
2093 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2094 pStrides = (VkDeviceSize*)stack_pStrides;
2095 } else {
2096 readStream->alloc((void**)&pStrides,
2097 ((bindingCount)) * sizeof(const VkDeviceSize));
2098 }
2099 memcpy((VkDeviceSize*)pStrides, *readStreamPtrPtr,
2100 ((bindingCount)) * sizeof(const VkDeviceSize));
2101 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
2102 }
2103 if (CC_LIKELY(vk)) {
2104 vk->vkCmdBindVertexBuffers2((VkCommandBuffer)dispatchHandle, firstBinding,
2105 bindingCount, pBuffers, pOffsets, pSizes, pStrides);
2106 }
2107 break;
2108 }
2109 case OP_vkCmdSetDepthTestEnable: {
2110 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2111 "VkSubDecoder vkCmdSetDepthTestEnable");
2112 VkBool32 depthTestEnable;
2113 memcpy((VkBool32*)&depthTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
2114 *readStreamPtrPtr += sizeof(VkBool32);
2115 if (CC_LIKELY(vk)) {
2116 vk->vkCmdSetDepthTestEnable((VkCommandBuffer)dispatchHandle, depthTestEnable);
2117 }
2118 break;
2119 }
2120 case OP_vkCmdSetDepthWriteEnable: {
2121 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2122 "VkSubDecoder vkCmdSetDepthWriteEnable");
2123 VkBool32 depthWriteEnable;
2124 memcpy((VkBool32*)&depthWriteEnable, *readStreamPtrPtr, sizeof(VkBool32));
2125 *readStreamPtrPtr += sizeof(VkBool32);
2126 if (CC_LIKELY(vk)) {
2127 vk->vkCmdSetDepthWriteEnable((VkCommandBuffer)dispatchHandle, depthWriteEnable);
2128 }
2129 break;
2130 }
2131 case OP_vkCmdSetDepthCompareOp: {
2132 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2133 "VkSubDecoder vkCmdSetDepthCompareOp");
2134 VkCompareOp depthCompareOp;
2135 memcpy((VkCompareOp*)&depthCompareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
2136 *readStreamPtrPtr += sizeof(VkCompareOp);
2137 if (CC_LIKELY(vk)) {
2138 vk->vkCmdSetDepthCompareOp((VkCommandBuffer)dispatchHandle, depthCompareOp);
2139 }
2140 break;
2141 }
2142 case OP_vkCmdSetDepthBoundsTestEnable: {
2143 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2144 "VkSubDecoder vkCmdSetDepthBoundsTestEnable");
2145 VkBool32 depthBoundsTestEnable;
2146 memcpy((VkBool32*)&depthBoundsTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
2147 *readStreamPtrPtr += sizeof(VkBool32);
2148 if (CC_LIKELY(vk)) {
2149 vk->vkCmdSetDepthBoundsTestEnable((VkCommandBuffer)dispatchHandle,
2150 depthBoundsTestEnable);
2151 }
2152 break;
2153 }
2154 case OP_vkCmdSetStencilTestEnable: {
2155 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2156 "VkSubDecoder vkCmdSetStencilTestEnable");
2157 VkBool32 stencilTestEnable;
2158 memcpy((VkBool32*)&stencilTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
2159 *readStreamPtrPtr += sizeof(VkBool32);
2160 if (CC_LIKELY(vk)) {
2161 vk->vkCmdSetStencilTestEnable((VkCommandBuffer)dispatchHandle,
2162 stencilTestEnable);
2163 }
2164 break;
2165 }
2166 case OP_vkCmdSetStencilOp: {
2167 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2168 "VkSubDecoder vkCmdSetStencilOp");
2169 VkStencilFaceFlags faceMask;
2170 VkStencilOp failOp;
2171 VkStencilOp passOp;
2172 VkStencilOp depthFailOp;
2173 VkCompareOp compareOp;
2174 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
2175 sizeof(VkStencilFaceFlags));
2176 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
2177 memcpy((VkStencilOp*)&failOp, *readStreamPtrPtr, sizeof(VkStencilOp));
2178 *readStreamPtrPtr += sizeof(VkStencilOp);
2179 memcpy((VkStencilOp*)&passOp, *readStreamPtrPtr, sizeof(VkStencilOp));
2180 *readStreamPtrPtr += sizeof(VkStencilOp);
2181 memcpy((VkStencilOp*)&depthFailOp, *readStreamPtrPtr, sizeof(VkStencilOp));
2182 *readStreamPtrPtr += sizeof(VkStencilOp);
2183 memcpy((VkCompareOp*)&compareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
2184 *readStreamPtrPtr += sizeof(VkCompareOp);
2185 if (CC_LIKELY(vk)) {
2186 vk->vkCmdSetStencilOp((VkCommandBuffer)dispatchHandle, faceMask, failOp, passOp,
2187 depthFailOp, compareOp);
2188 }
2189 break;
2190 }
2191 case OP_vkCmdSetRasterizerDiscardEnable: {
2192 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2193 "VkSubDecoder vkCmdSetRasterizerDiscardEnable");
2194 VkBool32 rasterizerDiscardEnable;
2195 memcpy((VkBool32*)&rasterizerDiscardEnable, *readStreamPtrPtr, sizeof(VkBool32));
2196 *readStreamPtrPtr += sizeof(VkBool32);
2197 if (CC_LIKELY(vk)) {
2198 vk->vkCmdSetRasterizerDiscardEnable((VkCommandBuffer)dispatchHandle,
2199 rasterizerDiscardEnable);
2200 }
2201 break;
2202 }
2203 case OP_vkCmdSetDepthBiasEnable: {
2204 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2205 "VkSubDecoder vkCmdSetDepthBiasEnable");
2206 VkBool32 depthBiasEnable;
2207 memcpy((VkBool32*)&depthBiasEnable, *readStreamPtrPtr, sizeof(VkBool32));
2208 *readStreamPtrPtr += sizeof(VkBool32);
2209 if (CC_LIKELY(vk)) {
2210 vk->vkCmdSetDepthBiasEnable((VkCommandBuffer)dispatchHandle, depthBiasEnable);
2211 }
2212 break;
2213 }
2214 case OP_vkCmdSetPrimitiveRestartEnable: {
2215 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2216 "VkSubDecoder vkCmdSetPrimitiveRestartEnable");
2217 VkBool32 primitiveRestartEnable;
2218 memcpy((VkBool32*)&primitiveRestartEnable, *readStreamPtrPtr, sizeof(VkBool32));
2219 *readStreamPtrPtr += sizeof(VkBool32);
2220 if (CC_LIKELY(vk)) {
2221 vk->vkCmdSetPrimitiveRestartEnable((VkCommandBuffer)dispatchHandle,
2222 primitiveRestartEnable);
2223 }
2224 break;
2225 }
2226 #endif
2227 #ifdef VK_KHR_dynamic_rendering
2228 case OP_vkCmdBeginRenderingKHR: {
2229 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2230 "VkSubDecoder vkCmdBeginRenderingKHR");
2231 const VkRenderingInfo* pRenderingInfo;
2232 VkRenderingInfo stack_pRenderingInfo[1];
2233 pRenderingInfo = (VkRenderingInfo*)stack_pRenderingInfo;
2234 reservedunmarshal_VkRenderingInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2235 (VkRenderingInfo*)(pRenderingInfo),
2236 readStreamPtrPtr);
2237 if (pRenderingInfo) {
2238 transform_tohost_VkRenderingInfo(globalstate,
2239 (VkRenderingInfo*)(pRenderingInfo));
2240 }
2241 if (CC_LIKELY(vk)) {
2242 vk->vkCmdBeginRenderingKHR((VkCommandBuffer)dispatchHandle, pRenderingInfo);
2243 }
2244 break;
2245 }
2246 case OP_vkCmdEndRenderingKHR: {
2247 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2248 "VkSubDecoder vkCmdEndRenderingKHR");
2249 if (CC_LIKELY(vk)) {
2250 vk->vkCmdEndRenderingKHR((VkCommandBuffer)dispatchHandle);
2251 }
2252 break;
2253 }
2254 #endif
2255 #ifdef VK_KHR_create_renderpass2
2256 case OP_vkCmdBeginRenderPass2KHR: {
2257 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2258 "VkSubDecoder vkCmdBeginRenderPass2KHR");
2259 const VkRenderPassBeginInfo* pRenderPassBegin;
2260 VkRenderPassBeginInfo stack_pRenderPassBegin[1];
2261 const VkSubpassBeginInfo* pSubpassBeginInfo;
2262 VkSubpassBeginInfo stack_pSubpassBeginInfo[1];
2263 pRenderPassBegin = (VkRenderPassBeginInfo*)stack_pRenderPassBegin;
2264 reservedunmarshal_VkRenderPassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2265 (VkRenderPassBeginInfo*)(pRenderPassBegin),
2266 readStreamPtrPtr);
2267 pSubpassBeginInfo = (VkSubpassBeginInfo*)stack_pSubpassBeginInfo;
2268 reservedunmarshal_VkSubpassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2269 (VkSubpassBeginInfo*)(pSubpassBeginInfo),
2270 readStreamPtrPtr);
2271 if (pRenderPassBegin) {
2272 transform_tohost_VkRenderPassBeginInfo(
2273 globalstate, (VkRenderPassBeginInfo*)(pRenderPassBegin));
2274 }
2275 if (pSubpassBeginInfo) {
2276 transform_tohost_VkSubpassBeginInfo(globalstate,
2277 (VkSubpassBeginInfo*)(pSubpassBeginInfo));
2278 }
2279 if (CC_LIKELY(vk)) {
2280 this->on_vkCmdBeginRenderPass2KHR(pool, nullptr,
2281 (VkCommandBuffer)(boxed_dispatchHandle),
2282 pRenderPassBegin, pSubpassBeginInfo);
2283 }
2284 break;
2285 }
2286 case OP_vkCmdNextSubpass2KHR: {
2287 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2288 "VkSubDecoder vkCmdNextSubpass2KHR");
2289 const VkSubpassBeginInfo* pSubpassBeginInfo;
2290 VkSubpassBeginInfo stack_pSubpassBeginInfo[1];
2291 const VkSubpassEndInfo* pSubpassEndInfo;
2292 VkSubpassEndInfo stack_pSubpassEndInfo[1];
2293 pSubpassBeginInfo = (VkSubpassBeginInfo*)stack_pSubpassBeginInfo;
2294 reservedunmarshal_VkSubpassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2295 (VkSubpassBeginInfo*)(pSubpassBeginInfo),
2296 readStreamPtrPtr);
2297 pSubpassEndInfo = (VkSubpassEndInfo*)stack_pSubpassEndInfo;
2298 reservedunmarshal_VkSubpassEndInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2299 (VkSubpassEndInfo*)(pSubpassEndInfo),
2300 readStreamPtrPtr);
2301 if (pSubpassBeginInfo) {
2302 transform_tohost_VkSubpassBeginInfo(globalstate,
2303 (VkSubpassBeginInfo*)(pSubpassBeginInfo));
2304 }
2305 if (pSubpassEndInfo) {
2306 transform_tohost_VkSubpassEndInfo(globalstate,
2307 (VkSubpassEndInfo*)(pSubpassEndInfo));
2308 }
2309 if (CC_LIKELY(vk)) {
2310 vk->vkCmdNextSubpass2KHR((VkCommandBuffer)dispatchHandle, pSubpassBeginInfo,
2311 pSubpassEndInfo);
2312 }
2313 break;
2314 }
2315 case OP_vkCmdEndRenderPass2KHR: {
2316 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2317 "VkSubDecoder vkCmdEndRenderPass2KHR");
2318 const VkSubpassEndInfo* pSubpassEndInfo;
2319 VkSubpassEndInfo stack_pSubpassEndInfo[1];
2320 pSubpassEndInfo = (VkSubpassEndInfo*)stack_pSubpassEndInfo;
2321 reservedunmarshal_VkSubpassEndInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2322 (VkSubpassEndInfo*)(pSubpassEndInfo),
2323 readStreamPtrPtr);
2324 if (pSubpassEndInfo) {
2325 transform_tohost_VkSubpassEndInfo(globalstate,
2326 (VkSubpassEndInfo*)(pSubpassEndInfo));
2327 }
2328 if (CC_LIKELY(vk)) {
2329 vk->vkCmdEndRenderPass2KHR((VkCommandBuffer)dispatchHandle, pSubpassEndInfo);
2330 }
2331 break;
2332 }
2333 #endif
2334 #ifdef VK_KHR_synchronization2
2335 case OP_vkCmdSetEvent2KHR: {
2336 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2337 "VkSubDecoder vkCmdSetEvent2KHR");
2338 VkEvent event;
2339 const VkDependencyInfo* pDependencyInfo;
2340 VkDependencyInfo stack_pDependencyInfo[1];
2341 uint64_t cgen_var_0;
2342 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2343 *readStreamPtrPtr += 1 * 8;
2344 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
2345 pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
2346 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2347 (VkDependencyInfo*)(pDependencyInfo),
2348 readStreamPtrPtr);
2349 if (pDependencyInfo) {
2350 transform_tohost_VkDependencyInfo(globalstate,
2351 (VkDependencyInfo*)(pDependencyInfo));
2352 }
2353 if (CC_LIKELY(vk)) {
2354 vk->vkCmdSetEvent2KHR((VkCommandBuffer)dispatchHandle, event, pDependencyInfo);
2355 }
2356 break;
2357 }
2358 case OP_vkCmdResetEvent2KHR: {
2359 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2360 "VkSubDecoder vkCmdResetEvent2KHR");
2361 VkEvent event;
2362 VkPipelineStageFlags2 stageMask;
2363 uint64_t cgen_var_0;
2364 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2365 *readStreamPtrPtr += 1 * 8;
2366 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
2367 memcpy((VkPipelineStageFlags2*)&stageMask, *readStreamPtrPtr,
2368 sizeof(VkPipelineStageFlags2));
2369 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
2370 if (CC_LIKELY(vk)) {
2371 vk->vkCmdResetEvent2KHR((VkCommandBuffer)dispatchHandle, event, stageMask);
2372 }
2373 break;
2374 }
2375 case OP_vkCmdWaitEvents2KHR: {
2376 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2377 "VkSubDecoder vkCmdWaitEvents2KHR");
2378 uint32_t eventCount;
2379 const VkEvent* pEvents;
2380 VkEvent stack_pEvents[MAX_STACK_ITEMS];
2381 const VkDependencyInfo* pDependencyInfos;
2382 VkDependencyInfo stack_pDependencyInfos[MAX_STACK_ITEMS];
2383 memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
2384 *readStreamPtrPtr += sizeof(uint32_t);
2385 if (((eventCount)) <= MAX_STACK_ITEMS) {
2386 pEvents = (VkEvent*)stack_pEvents;
2387 } else {
2388 readStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
2389 }
2390 if (((eventCount))) {
2391 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2392 *readStreamPtrPtr += 8 * ((eventCount));
2393 for (uint32_t k = 0; k < ((eventCount)); ++k) {
2394 uint64_t tmpval;
2395 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
2396 *(((VkEvent*)pEvents) + k) =
2397 tmpval ? (VkEvent)unbox_VkEvent((VkEvent)tmpval) : VK_NULL_HANDLE;
2398 }
2399 }
2400 if (((eventCount)) <= MAX_STACK_ITEMS) {
2401 pDependencyInfos = (VkDependencyInfo*)stack_pDependencyInfos;
2402 } else {
2403 readStream->alloc((void**)&pDependencyInfos,
2404 ((eventCount)) * sizeof(const VkDependencyInfo));
2405 }
2406 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
2407 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2408 (VkDependencyInfo*)(pDependencyInfos + i),
2409 readStreamPtrPtr);
2410 }
2411 if (pDependencyInfos) {
2412 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
2413 transform_tohost_VkDependencyInfo(
2414 globalstate, (VkDependencyInfo*)(pDependencyInfos + i));
2415 }
2416 }
2417 if (CC_LIKELY(vk)) {
2418 vk->vkCmdWaitEvents2KHR((VkCommandBuffer)dispatchHandle, eventCount, pEvents,
2419 pDependencyInfos);
2420 }
2421 break;
2422 }
2423 case OP_vkCmdPipelineBarrier2KHR: {
2424 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2425 "VkSubDecoder vkCmdPipelineBarrier2KHR");
2426 const VkDependencyInfo* pDependencyInfo;
2427 VkDependencyInfo stack_pDependencyInfo[1];
2428 pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
2429 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2430 (VkDependencyInfo*)(pDependencyInfo),
2431 readStreamPtrPtr);
2432 if (pDependencyInfo) {
2433 transform_tohost_VkDependencyInfo(globalstate,
2434 (VkDependencyInfo*)(pDependencyInfo));
2435 }
2436 if (CC_LIKELY(vk)) {
2437 vk->vkCmdPipelineBarrier2KHR((VkCommandBuffer)dispatchHandle, pDependencyInfo);
2438 }
2439 break;
2440 }
2441 case OP_vkCmdWriteTimestamp2KHR: {
2442 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2443 "VkSubDecoder vkCmdWriteTimestamp2KHR");
2444 VkPipelineStageFlags2 stage;
2445 VkQueryPool queryPool;
2446 uint32_t query;
2447 memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
2448 sizeof(VkPipelineStageFlags2));
2449 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
2450 uint64_t cgen_var_0;
2451 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2452 *readStreamPtrPtr += 1 * 8;
2453 *(VkQueryPool*)&queryPool =
2454 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
2455 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
2456 *readStreamPtrPtr += sizeof(uint32_t);
2457 if (CC_LIKELY(vk)) {
2458 vk->vkCmdWriteTimestamp2KHR((VkCommandBuffer)dispatchHandle, stage, queryPool,
2459 query);
2460 }
2461 break;
2462 }
2463 case OP_vkCmdWriteBufferMarker2AMD: {
2464 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2465 "VkSubDecoder vkCmdWriteBufferMarker2AMD");
2466 VkPipelineStageFlags2 stage;
2467 VkBuffer dstBuffer;
2468 VkDeviceSize dstOffset;
2469 uint32_t marker;
2470 memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
2471 sizeof(VkPipelineStageFlags2));
2472 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
2473 uint64_t cgen_var_0;
2474 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2475 *readStreamPtrPtr += 1 * 8;
2476 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
2477 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2478 *readStreamPtrPtr += sizeof(VkDeviceSize);
2479 memcpy((uint32_t*)&marker, *readStreamPtrPtr, sizeof(uint32_t));
2480 *readStreamPtrPtr += sizeof(uint32_t);
2481 if (CC_LIKELY(vk)) {
2482 vk->vkCmdWriteBufferMarker2AMD((VkCommandBuffer)dispatchHandle, stage,
2483 dstBuffer, dstOffset, marker);
2484 }
2485 break;
2486 }
2487 #endif
2488 #ifdef VK_KHR_copy_commands2
2489 case OP_vkCmdCopyBuffer2KHR: {
2490 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2491 "VkSubDecoder vkCmdCopyBuffer2KHR");
2492 const VkCopyBufferInfo2* pCopyBufferInfo;
2493 VkCopyBufferInfo2 stack_pCopyBufferInfo[1];
2494 pCopyBufferInfo = (VkCopyBufferInfo2*)stack_pCopyBufferInfo;
2495 reservedunmarshal_VkCopyBufferInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2496 (VkCopyBufferInfo2*)(pCopyBufferInfo),
2497 readStreamPtrPtr);
2498 if (pCopyBufferInfo) {
2499 transform_tohost_VkCopyBufferInfo2(globalstate,
2500 (VkCopyBufferInfo2*)(pCopyBufferInfo));
2501 }
2502 if (CC_LIKELY(vk)) {
2503 vk->vkCmdCopyBuffer2KHR((VkCommandBuffer)dispatchHandle, pCopyBufferInfo);
2504 }
2505 break;
2506 }
2507 case OP_vkCmdCopyImage2KHR: {
2508 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2509 "VkSubDecoder vkCmdCopyImage2KHR");
2510 const VkCopyImageInfo2* pCopyImageInfo;
2511 VkCopyImageInfo2 stack_pCopyImageInfo[1];
2512 pCopyImageInfo = (VkCopyImageInfo2*)stack_pCopyImageInfo;
2513 reservedunmarshal_VkCopyImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2514 (VkCopyImageInfo2*)(pCopyImageInfo),
2515 readStreamPtrPtr);
2516 if (pCopyImageInfo) {
2517 transform_tohost_VkCopyImageInfo2(globalstate,
2518 (VkCopyImageInfo2*)(pCopyImageInfo));
2519 }
2520 if (CC_LIKELY(vk)) {
2521 this->on_vkCmdCopyImage2KHR(
2522 pool, nullptr, (VkCommandBuffer)(boxed_dispatchHandle), pCopyImageInfo);
2523 }
2524 break;
2525 }
2526 case OP_vkCmdCopyBufferToImage2KHR: {
2527 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2528 "VkSubDecoder vkCmdCopyBufferToImage2KHR");
2529 const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo;
2530 VkCopyBufferToImageInfo2 stack_pCopyBufferToImageInfo[1];
2531 pCopyBufferToImageInfo = (VkCopyBufferToImageInfo2*)stack_pCopyBufferToImageInfo;
2532 reservedunmarshal_VkCopyBufferToImageInfo2(
2533 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2534 (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo), readStreamPtrPtr);
2535 if (pCopyBufferToImageInfo) {
2536 transform_tohost_VkCopyBufferToImageInfo2(
2537 globalstate, (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo));
2538 }
2539 if (CC_LIKELY(vk)) {
2540 this->on_vkCmdCopyBufferToImage2KHR(pool, nullptr,
2541 (VkCommandBuffer)(boxed_dispatchHandle),
2542 pCopyBufferToImageInfo, context);
2543 }
2544 break;
2545 }
2546 case OP_vkCmdCopyImageToBuffer2KHR: {
2547 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2548 "VkSubDecoder vkCmdCopyImageToBuffer2KHR");
2549 const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo;
2550 VkCopyImageToBufferInfo2 stack_pCopyImageToBufferInfo[1];
2551 pCopyImageToBufferInfo = (VkCopyImageToBufferInfo2*)stack_pCopyImageToBufferInfo;
2552 reservedunmarshal_VkCopyImageToBufferInfo2(
2553 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2554 (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo), readStreamPtrPtr);
2555 if (pCopyImageToBufferInfo) {
2556 transform_tohost_VkCopyImageToBufferInfo2(
2557 globalstate, (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo));
2558 }
2559 if (CC_LIKELY(vk)) {
2560 this->on_vkCmdCopyImageToBuffer2KHR(pool, nullptr,
2561 (VkCommandBuffer)(boxed_dispatchHandle),
2562 pCopyImageToBufferInfo);
2563 }
2564 break;
2565 }
2566 case OP_vkCmdBlitImage2KHR: {
2567 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2568 "VkSubDecoder vkCmdBlitImage2KHR");
2569 const VkBlitImageInfo2* pBlitImageInfo;
2570 VkBlitImageInfo2 stack_pBlitImageInfo[1];
2571 pBlitImageInfo = (VkBlitImageInfo2*)stack_pBlitImageInfo;
2572 reservedunmarshal_VkBlitImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2573 (VkBlitImageInfo2*)(pBlitImageInfo),
2574 readStreamPtrPtr);
2575 if (pBlitImageInfo) {
2576 transform_tohost_VkBlitImageInfo2(globalstate,
2577 (VkBlitImageInfo2*)(pBlitImageInfo));
2578 }
2579 if (CC_LIKELY(vk)) {
2580 vk->vkCmdBlitImage2KHR((VkCommandBuffer)dispatchHandle, pBlitImageInfo);
2581 }
2582 break;
2583 }
2584 case OP_vkCmdResolveImage2KHR: {
2585 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2586 "VkSubDecoder vkCmdResolveImage2KHR");
2587 const VkResolveImageInfo2* pResolveImageInfo;
2588 VkResolveImageInfo2 stack_pResolveImageInfo[1];
2589 pResolveImageInfo = (VkResolveImageInfo2*)stack_pResolveImageInfo;
2590 reservedunmarshal_VkResolveImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2591 (VkResolveImageInfo2*)(pResolveImageInfo),
2592 readStreamPtrPtr);
2593 if (pResolveImageInfo) {
2594 transform_tohost_VkResolveImageInfo2(globalstate,
2595 (VkResolveImageInfo2*)(pResolveImageInfo));
2596 }
2597 if (CC_LIKELY(vk)) {
2598 vk->vkCmdResolveImage2KHR((VkCommandBuffer)dispatchHandle, pResolveImageInfo);
2599 }
2600 break;
2601 }
2602 #endif
2603 #ifdef VK_KHR_maintenance5
2604 case OP_vkCmdBindIndexBuffer2KHR: {
2605 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2606 "VkSubDecoder vkCmdBindIndexBuffer2KHR");
2607 VkBuffer buffer;
2608 VkDeviceSize offset;
2609 VkDeviceSize size;
2610 VkIndexType indexType;
2611 uint64_t cgen_var_0;
2612 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2613 *readStreamPtrPtr += 1 * 8;
2614 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
2615 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2616 *readStreamPtrPtr += sizeof(VkDeviceSize);
2617 memcpy((VkDeviceSize*)&size, *readStreamPtrPtr, sizeof(VkDeviceSize));
2618 *readStreamPtrPtr += sizeof(VkDeviceSize);
2619 memcpy((VkIndexType*)&indexType, *readStreamPtrPtr, sizeof(VkIndexType));
2620 *readStreamPtrPtr += sizeof(VkIndexType);
2621 if (CC_LIKELY(vk)) {
2622 vk->vkCmdBindIndexBuffer2KHR((VkCommandBuffer)dispatchHandle, buffer, offset,
2623 size, indexType);
2624 }
2625 break;
2626 }
2627 #endif
2628 #ifdef VK_KHR_line_rasterization
2629 case OP_vkCmdSetLineStippleKHR: {
2630 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2631 "VkSubDecoder vkCmdSetLineStippleKHR");
2632 uint32_t lineStippleFactor;
2633 uint16_t lineStipplePattern;
2634 memcpy((uint32_t*)&lineStippleFactor, *readStreamPtrPtr, sizeof(uint32_t));
2635 *readStreamPtrPtr += sizeof(uint32_t);
2636 memcpy((uint16_t*)&lineStipplePattern, *readStreamPtrPtr, sizeof(uint16_t));
2637 *readStreamPtrPtr += sizeof(uint16_t);
2638 if (CC_LIKELY(vk)) {
2639 vk->vkCmdSetLineStippleKHR((VkCommandBuffer)dispatchHandle, lineStippleFactor,
2640 lineStipplePattern);
2641 }
2642 break;
2643 }
2644 #endif
2645 #ifdef VK_EXT_transform_feedback
2646 case OP_vkCmdBindTransformFeedbackBuffersEXT: {
2647 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2648 "VkSubDecoder vkCmdBindTransformFeedbackBuffersEXT");
2649 uint32_t firstBinding;
2650 uint32_t bindingCount;
2651 const VkBuffer* pBuffers;
2652 VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
2653 const VkDeviceSize* pOffsets;
2654 VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
2655 const VkDeviceSize* pSizes;
2656 VkDeviceSize stack_pSizes[MAX_STACK_ITEMS];
2657 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
2658 *readStreamPtrPtr += sizeof(uint32_t);
2659 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
2660 *readStreamPtrPtr += sizeof(uint32_t);
2661 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2662 pBuffers = (VkBuffer*)stack_pBuffers;
2663 } else {
2664 readStream->alloc((void**)&pBuffers, ((bindingCount)) * sizeof(const VkBuffer));
2665 }
2666 if (((bindingCount))) {
2667 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2668 *readStreamPtrPtr += 8 * ((bindingCount));
2669 for (uint32_t k = 0; k < ((bindingCount)); ++k) {
2670 uint64_t tmpval;
2671 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
2672 *(((VkBuffer*)pBuffers) + k) =
2673 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval) : VK_NULL_HANDLE;
2674 }
2675 }
2676 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2677 pOffsets = (VkDeviceSize*)stack_pOffsets;
2678 } else {
2679 readStream->alloc((void**)&pOffsets,
2680 ((bindingCount)) * sizeof(const VkDeviceSize));
2681 }
2682 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
2683 ((bindingCount)) * sizeof(const VkDeviceSize));
2684 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
2685 // WARNING PTR CHECK
2686 memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
2687 android::base::Stream::fromBe64((uint8_t*)&pSizes);
2688 *readStreamPtrPtr += 8;
2689 if (pSizes) {
2690 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2691 pSizes = (VkDeviceSize*)stack_pSizes;
2692 } else {
2693 readStream->alloc((void**)&pSizes,
2694 ((bindingCount)) * sizeof(const VkDeviceSize));
2695 }
2696 memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr,
2697 ((bindingCount)) * sizeof(const VkDeviceSize));
2698 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
2699 }
2700 if (CC_LIKELY(vk)) {
2701 vk->vkCmdBindTransformFeedbackBuffersEXT((VkCommandBuffer)dispatchHandle,
2702 firstBinding, bindingCount, pBuffers,
2703 pOffsets, pSizes);
2704 }
2705 break;
2706 }
2707 case OP_vkCmdBeginTransformFeedbackEXT: {
2708 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2709 "VkSubDecoder vkCmdBeginTransformFeedbackEXT");
2710 uint32_t firstCounterBuffer;
2711 uint32_t counterBufferCount;
2712 const VkBuffer* pCounterBuffers;
2713 VkBuffer stack_pCounterBuffers[MAX_STACK_ITEMS];
2714 const VkDeviceSize* pCounterBufferOffsets;
2715 VkDeviceSize stack_pCounterBufferOffsets[MAX_STACK_ITEMS];
2716 memcpy((uint32_t*)&firstCounterBuffer, *readStreamPtrPtr, sizeof(uint32_t));
2717 *readStreamPtrPtr += sizeof(uint32_t);
2718 memcpy((uint32_t*)&counterBufferCount, *readStreamPtrPtr, sizeof(uint32_t));
2719 *readStreamPtrPtr += sizeof(uint32_t);
2720 // WARNING PTR CHECK
2721 memcpy((VkBuffer**)&pCounterBuffers, (*readStreamPtrPtr), 8);
2722 android::base::Stream::fromBe64((uint8_t*)&pCounterBuffers);
2723 *readStreamPtrPtr += 8;
2724 if (pCounterBuffers) {
2725 if (((counterBufferCount)) <= MAX_STACK_ITEMS) {
2726 pCounterBuffers = (VkBuffer*)stack_pCounterBuffers;
2727 } else {
2728 readStream->alloc((void**)&pCounterBuffers,
2729 ((counterBufferCount)) * sizeof(const VkBuffer));
2730 }
2731 if (((counterBufferCount))) {
2732 uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2733 *readStreamPtrPtr += 8 * ((counterBufferCount));
2734 for (uint32_t k = 0; k < ((counterBufferCount)); ++k) {
2735 uint64_t tmpval;
2736 memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
2737 *(((VkBuffer*)pCounterBuffers) + k) =
2738 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval)
2739 : VK_NULL_HANDLE;
2740 }
2741 }
2742 }
2743 // WARNING PTR CHECK
2744 memcpy((VkDeviceSize**)&pCounterBufferOffsets, (*readStreamPtrPtr), 8);
2745 android::base::Stream::fromBe64((uint8_t*)&pCounterBufferOffsets);
2746 *readStreamPtrPtr += 8;
2747 if (pCounterBufferOffsets) {
2748 if (((counterBufferCount)) <= MAX_STACK_ITEMS) {
2749 pCounterBufferOffsets = (VkDeviceSize*)stack_pCounterBufferOffsets;
2750 } else {
2751 readStream->alloc((void**)&pCounterBufferOffsets,
2752 ((counterBufferCount)) * sizeof(const VkDeviceSize));
2753 }
2754 memcpy((VkDeviceSize*)pCounterBufferOffsets, *readStreamPtrPtr,
2755 ((counterBufferCount)) * sizeof(const VkDeviceSize));
2756 *readStreamPtrPtr += ((counterBufferCount)) * sizeof(const VkDeviceSize);
2757 }
2758 if (CC_LIKELY(vk)) {
2759 vk->vkCmdBeginTransformFeedbackEXT((VkCommandBuffer)dispatchHandle,
2760 firstCounterBuffer, counterBufferCount,
2761 pCounterBuffers, pCounterBufferOffsets);
2762 }
2763 break;
2764 }
2765 case OP_vkCmdEndTransformFeedbackEXT: {
2766 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2767 "VkSubDecoder vkCmdEndTransformFeedbackEXT");
2768 uint32_t firstCounterBuffer;
2769 uint32_t counterBufferCount;
2770 const VkBuffer* pCounterBuffers;
2771 VkBuffer stack_pCounterBuffers[MAX_STACK_ITEMS];
2772 const VkDeviceSize* pCounterBufferOffsets;
2773 VkDeviceSize stack_pCounterBufferOffsets[MAX_STACK_ITEMS];
2774 memcpy((uint32_t*)&firstCounterBuffer, *readStreamPtrPtr, sizeof(uint32_t));
2775 *readStreamPtrPtr += sizeof(uint32_t);
2776 memcpy((uint32_t*)&counterBufferCount, *readStreamPtrPtr, sizeof(uint32_t));
2777 *readStreamPtrPtr += sizeof(uint32_t);
2778 // WARNING PTR CHECK
2779 memcpy((VkBuffer**)&pCounterBuffers, (*readStreamPtrPtr), 8);
2780 android::base::Stream::fromBe64((uint8_t*)&pCounterBuffers);
2781 *readStreamPtrPtr += 8;
2782 if (pCounterBuffers) {
2783 if (((counterBufferCount)) <= MAX_STACK_ITEMS) {
2784 pCounterBuffers = (VkBuffer*)stack_pCounterBuffers;
2785 } else {
2786 readStream->alloc((void**)&pCounterBuffers,
2787 ((counterBufferCount)) * sizeof(const VkBuffer));
2788 }
2789 if (((counterBufferCount))) {
2790 uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2791 *readStreamPtrPtr += 8 * ((counterBufferCount));
2792 for (uint32_t k = 0; k < ((counterBufferCount)); ++k) {
2793 uint64_t tmpval;
2794 memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
2795 *(((VkBuffer*)pCounterBuffers) + k) =
2796 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval)
2797 : VK_NULL_HANDLE;
2798 }
2799 }
2800 }
2801 // WARNING PTR CHECK
2802 memcpy((VkDeviceSize**)&pCounterBufferOffsets, (*readStreamPtrPtr), 8);
2803 android::base::Stream::fromBe64((uint8_t*)&pCounterBufferOffsets);
2804 *readStreamPtrPtr += 8;
2805 if (pCounterBufferOffsets) {
2806 if (((counterBufferCount)) <= MAX_STACK_ITEMS) {
2807 pCounterBufferOffsets = (VkDeviceSize*)stack_pCounterBufferOffsets;
2808 } else {
2809 readStream->alloc((void**)&pCounterBufferOffsets,
2810 ((counterBufferCount)) * sizeof(const VkDeviceSize));
2811 }
2812 memcpy((VkDeviceSize*)pCounterBufferOffsets, *readStreamPtrPtr,
2813 ((counterBufferCount)) * sizeof(const VkDeviceSize));
2814 *readStreamPtrPtr += ((counterBufferCount)) * sizeof(const VkDeviceSize);
2815 }
2816 if (CC_LIKELY(vk)) {
2817 vk->vkCmdEndTransformFeedbackEXT((VkCommandBuffer)dispatchHandle,
2818 firstCounterBuffer, counterBufferCount,
2819 pCounterBuffers, pCounterBufferOffsets);
2820 }
2821 break;
2822 }
2823 case OP_vkCmdBeginQueryIndexedEXT: {
2824 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2825 "VkSubDecoder vkCmdBeginQueryIndexedEXT");
2826 VkQueryPool queryPool;
2827 uint32_t query;
2828 VkQueryControlFlags flags;
2829 uint32_t index;
2830 uint64_t cgen_var_0;
2831 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2832 *readStreamPtrPtr += 1 * 8;
2833 *(VkQueryPool*)&queryPool =
2834 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
2835 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
2836 *readStreamPtrPtr += sizeof(uint32_t);
2837 memcpy((VkQueryControlFlags*)&flags, *readStreamPtrPtr,
2838 sizeof(VkQueryControlFlags));
2839 *readStreamPtrPtr += sizeof(VkQueryControlFlags);
2840 memcpy((uint32_t*)&index, *readStreamPtrPtr, sizeof(uint32_t));
2841 *readStreamPtrPtr += sizeof(uint32_t);
2842 if (CC_LIKELY(vk)) {
2843 vk->vkCmdBeginQueryIndexedEXT((VkCommandBuffer)dispatchHandle, queryPool, query,
2844 flags, index);
2845 }
2846 break;
2847 }
2848 case OP_vkCmdEndQueryIndexedEXT: {
2849 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2850 "VkSubDecoder vkCmdEndQueryIndexedEXT");
2851 VkQueryPool queryPool;
2852 uint32_t query;
2853 uint32_t index;
2854 uint64_t cgen_var_0;
2855 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2856 *readStreamPtrPtr += 1 * 8;
2857 *(VkQueryPool*)&queryPool =
2858 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
2859 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
2860 *readStreamPtrPtr += sizeof(uint32_t);
2861 memcpy((uint32_t*)&index, *readStreamPtrPtr, sizeof(uint32_t));
2862 *readStreamPtrPtr += sizeof(uint32_t);
2863 if (CC_LIKELY(vk)) {
2864 vk->vkCmdEndQueryIndexedEXT((VkCommandBuffer)dispatchHandle, queryPool, query,
2865 index);
2866 }
2867 break;
2868 }
2869 case OP_vkCmdDrawIndirectByteCountEXT: {
2870 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2871 "VkSubDecoder vkCmdDrawIndirectByteCountEXT");
2872 uint32_t instanceCount;
2873 uint32_t firstInstance;
2874 VkBuffer counterBuffer;
2875 VkDeviceSize counterBufferOffset;
2876 uint32_t counterOffset;
2877 uint32_t vertexStride;
2878 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
2879 *readStreamPtrPtr += sizeof(uint32_t);
2880 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
2881 *readStreamPtrPtr += sizeof(uint32_t);
2882 uint64_t cgen_var_0;
2883 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2884 *readStreamPtrPtr += 1 * 8;
2885 *(VkBuffer*)&counterBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
2886 memcpy((VkDeviceSize*)&counterBufferOffset, *readStreamPtrPtr,
2887 sizeof(VkDeviceSize));
2888 *readStreamPtrPtr += sizeof(VkDeviceSize);
2889 memcpy((uint32_t*)&counterOffset, *readStreamPtrPtr, sizeof(uint32_t));
2890 *readStreamPtrPtr += sizeof(uint32_t);
2891 memcpy((uint32_t*)&vertexStride, *readStreamPtrPtr, sizeof(uint32_t));
2892 *readStreamPtrPtr += sizeof(uint32_t);
2893 if (CC_LIKELY(vk)) {
2894 vk->vkCmdDrawIndirectByteCountEXT(
2895 (VkCommandBuffer)dispatchHandle, instanceCount, firstInstance,
2896 counterBuffer, counterBufferOffset, counterOffset, vertexStride);
2897 }
2898 break;
2899 }
2900 #endif
2901 #ifdef VK_EXT_debug_utils
2902 case OP_vkCmdBeginDebugUtilsLabelEXT: {
2903 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2904 "VkSubDecoder vkCmdBeginDebugUtilsLabelEXT");
2905 const VkDebugUtilsLabelEXT* pLabelInfo;
2906 VkDebugUtilsLabelEXT stack_pLabelInfo[1];
2907 pLabelInfo = (VkDebugUtilsLabelEXT*)stack_pLabelInfo;
2908 reservedunmarshal_VkDebugUtilsLabelEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2909 (VkDebugUtilsLabelEXT*)(pLabelInfo),
2910 readStreamPtrPtr);
2911 if (pLabelInfo) {
2912 transform_tohost_VkDebugUtilsLabelEXT(globalstate,
2913 (VkDebugUtilsLabelEXT*)(pLabelInfo));
2914 }
2915 if (CC_LIKELY(vk)) {
2916 vk->vkCmdBeginDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle, pLabelInfo);
2917 }
2918 break;
2919 }
2920 case OP_vkCmdEndDebugUtilsLabelEXT: {
2921 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2922 "VkSubDecoder vkCmdEndDebugUtilsLabelEXT");
2923 if (CC_LIKELY(vk)) {
2924 vk->vkCmdEndDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle);
2925 }
2926 break;
2927 }
2928 case OP_vkCmdInsertDebugUtilsLabelEXT: {
2929 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2930 "VkSubDecoder vkCmdInsertDebugUtilsLabelEXT");
2931 const VkDebugUtilsLabelEXT* pLabelInfo;
2932 VkDebugUtilsLabelEXT stack_pLabelInfo[1];
2933 pLabelInfo = (VkDebugUtilsLabelEXT*)stack_pLabelInfo;
2934 reservedunmarshal_VkDebugUtilsLabelEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2935 (VkDebugUtilsLabelEXT*)(pLabelInfo),
2936 readStreamPtrPtr);
2937 if (pLabelInfo) {
2938 transform_tohost_VkDebugUtilsLabelEXT(globalstate,
2939 (VkDebugUtilsLabelEXT*)(pLabelInfo));
2940 }
2941 if (CC_LIKELY(vk)) {
2942 vk->vkCmdInsertDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle, pLabelInfo);
2943 }
2944 break;
2945 }
2946 #endif
2947 #ifdef VK_EXT_line_rasterization
2948 case OP_vkCmdSetLineStippleEXT: {
2949 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2950 "VkSubDecoder vkCmdSetLineStippleEXT");
2951 uint32_t lineStippleFactor;
2952 uint16_t lineStipplePattern;
2953 memcpy((uint32_t*)&lineStippleFactor, *readStreamPtrPtr, sizeof(uint32_t));
2954 *readStreamPtrPtr += sizeof(uint32_t);
2955 memcpy((uint16_t*)&lineStipplePattern, *readStreamPtrPtr, sizeof(uint16_t));
2956 *readStreamPtrPtr += sizeof(uint16_t);
2957 if (CC_LIKELY(vk)) {
2958 vk->vkCmdSetLineStippleEXT((VkCommandBuffer)dispatchHandle, lineStippleFactor,
2959 lineStipplePattern);
2960 }
2961 break;
2962 }
2963 #endif
2964 #ifdef VK_EXT_extended_dynamic_state
2965 case OP_vkCmdSetCullModeEXT: {
2966 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2967 "VkSubDecoder vkCmdSetCullModeEXT");
2968 VkCullModeFlags cullMode;
2969 memcpy((VkCullModeFlags*)&cullMode, *readStreamPtrPtr, sizeof(VkCullModeFlags));
2970 *readStreamPtrPtr += sizeof(VkCullModeFlags);
2971 if (CC_LIKELY(vk)) {
2972 vk->vkCmdSetCullModeEXT((VkCommandBuffer)dispatchHandle, cullMode);
2973 }
2974 break;
2975 }
2976 case OP_vkCmdSetFrontFaceEXT: {
2977 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2978 "VkSubDecoder vkCmdSetFrontFaceEXT");
2979 VkFrontFace frontFace;
2980 memcpy((VkFrontFace*)&frontFace, *readStreamPtrPtr, sizeof(VkFrontFace));
2981 *readStreamPtrPtr += sizeof(VkFrontFace);
2982 if (CC_LIKELY(vk)) {
2983 vk->vkCmdSetFrontFaceEXT((VkCommandBuffer)dispatchHandle, frontFace);
2984 }
2985 break;
2986 }
2987 case OP_vkCmdSetPrimitiveTopologyEXT: {
2988 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2989 "VkSubDecoder vkCmdSetPrimitiveTopologyEXT");
2990 VkPrimitiveTopology primitiveTopology;
2991 memcpy((VkPrimitiveTopology*)&primitiveTopology, *readStreamPtrPtr,
2992 sizeof(VkPrimitiveTopology));
2993 *readStreamPtrPtr += sizeof(VkPrimitiveTopology);
2994 if (CC_LIKELY(vk)) {
2995 vk->vkCmdSetPrimitiveTopologyEXT((VkCommandBuffer)dispatchHandle,
2996 primitiveTopology);
2997 }
2998 break;
2999 }
3000 case OP_vkCmdSetViewportWithCountEXT: {
3001 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3002 "VkSubDecoder vkCmdSetViewportWithCountEXT");
3003 uint32_t viewportCount;
3004 const VkViewport* pViewports;
3005 VkViewport stack_pViewports[MAX_STACK_ITEMS];
3006 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
3007 *readStreamPtrPtr += sizeof(uint32_t);
3008 if (((viewportCount)) <= MAX_STACK_ITEMS) {
3009 pViewports = (VkViewport*)stack_pViewports;
3010 } else {
3011 readStream->alloc((void**)&pViewports,
3012 ((viewportCount)) * sizeof(const VkViewport));
3013 }
3014 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
3015 reservedunmarshal_VkViewport(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3016 (VkViewport*)(pViewports + i), readStreamPtrPtr);
3017 }
3018 if (pViewports) {
3019 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
3020 transform_tohost_VkViewport(globalstate, (VkViewport*)(pViewports + i));
3021 }
3022 }
3023 if (CC_LIKELY(vk)) {
3024 vk->vkCmdSetViewportWithCountEXT((VkCommandBuffer)dispatchHandle, viewportCount,
3025 pViewports);
3026 }
3027 break;
3028 }
3029 case OP_vkCmdSetScissorWithCountEXT: {
3030 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3031 "VkSubDecoder vkCmdSetScissorWithCountEXT");
3032 uint32_t scissorCount;
3033 const VkRect2D* pScissors;
3034 VkRect2D stack_pScissors[MAX_STACK_ITEMS];
3035 memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
3036 *readStreamPtrPtr += sizeof(uint32_t);
3037 if (((scissorCount)) <= MAX_STACK_ITEMS) {
3038 pScissors = (VkRect2D*)stack_pScissors;
3039 } else {
3040 readStream->alloc((void**)&pScissors,
3041 ((scissorCount)) * sizeof(const VkRect2D));
3042 }
3043 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
3044 reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3045 (VkRect2D*)(pScissors + i), readStreamPtrPtr);
3046 }
3047 if (pScissors) {
3048 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
3049 transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pScissors + i));
3050 }
3051 }
3052 if (CC_LIKELY(vk)) {
3053 vk->vkCmdSetScissorWithCountEXT((VkCommandBuffer)dispatchHandle, scissorCount,
3054 pScissors);
3055 }
3056 break;
3057 }
3058 case OP_vkCmdBindVertexBuffers2EXT: {
3059 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3060 "VkSubDecoder vkCmdBindVertexBuffers2EXT");
3061 uint32_t firstBinding;
3062 uint32_t bindingCount;
3063 const VkBuffer* pBuffers;
3064 VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
3065 const VkDeviceSize* pOffsets;
3066 VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
3067 const VkDeviceSize* pSizes;
3068 VkDeviceSize stack_pSizes[MAX_STACK_ITEMS];
3069 const VkDeviceSize* pStrides;
3070 VkDeviceSize stack_pStrides[MAX_STACK_ITEMS];
3071 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
3072 *readStreamPtrPtr += sizeof(uint32_t);
3073 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
3074 *readStreamPtrPtr += sizeof(uint32_t);
3075 // WARNING PTR CHECK
3076 memcpy((VkBuffer**)&pBuffers, (*readStreamPtrPtr), 8);
3077 android::base::Stream::fromBe64((uint8_t*)&pBuffers);
3078 *readStreamPtrPtr += 8;
3079 if (pBuffers) {
3080 if (((bindingCount)) <= MAX_STACK_ITEMS) {
3081 pBuffers = (VkBuffer*)stack_pBuffers;
3082 } else {
3083 readStream->alloc((void**)&pBuffers,
3084 ((bindingCount)) * sizeof(const VkBuffer));
3085 }
3086 if (((bindingCount))) {
3087 uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
3088 *readStreamPtrPtr += 8 * ((bindingCount));
3089 for (uint32_t k = 0; k < ((bindingCount)); ++k) {
3090 uint64_t tmpval;
3091 memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
3092 *(((VkBuffer*)pBuffers) + k) =
3093 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval)
3094 : VK_NULL_HANDLE;
3095 }
3096 }
3097 }
3098 if (((bindingCount)) <= MAX_STACK_ITEMS) {
3099 pOffsets = (VkDeviceSize*)stack_pOffsets;
3100 } else {
3101 readStream->alloc((void**)&pOffsets,
3102 ((bindingCount)) * sizeof(const VkDeviceSize));
3103 }
3104 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
3105 ((bindingCount)) * sizeof(const VkDeviceSize));
3106 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
3107 // WARNING PTR CHECK
3108 memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
3109 android::base::Stream::fromBe64((uint8_t*)&pSizes);
3110 *readStreamPtrPtr += 8;
3111 if (pSizes) {
3112 if (((bindingCount)) <= MAX_STACK_ITEMS) {
3113 pSizes = (VkDeviceSize*)stack_pSizes;
3114 } else {
3115 readStream->alloc((void**)&pSizes,
3116 ((bindingCount)) * sizeof(const VkDeviceSize));
3117 }
3118 memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr,
3119 ((bindingCount)) * sizeof(const VkDeviceSize));
3120 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
3121 }
3122 // WARNING PTR CHECK
3123 memcpy((VkDeviceSize**)&pStrides, (*readStreamPtrPtr), 8);
3124 android::base::Stream::fromBe64((uint8_t*)&pStrides);
3125 *readStreamPtrPtr += 8;
3126 if (pStrides) {
3127 if (((bindingCount)) <= MAX_STACK_ITEMS) {
3128 pStrides = (VkDeviceSize*)stack_pStrides;
3129 } else {
3130 readStream->alloc((void**)&pStrides,
3131 ((bindingCount)) * sizeof(const VkDeviceSize));
3132 }
3133 memcpy((VkDeviceSize*)pStrides, *readStreamPtrPtr,
3134 ((bindingCount)) * sizeof(const VkDeviceSize));
3135 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
3136 }
3137 if (CC_LIKELY(vk)) {
3138 vk->vkCmdBindVertexBuffers2EXT((VkCommandBuffer)dispatchHandle, firstBinding,
3139 bindingCount, pBuffers, pOffsets, pSizes,
3140 pStrides);
3141 }
3142 break;
3143 }
3144 case OP_vkCmdSetDepthTestEnableEXT: {
3145 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3146 "VkSubDecoder vkCmdSetDepthTestEnableEXT");
3147 VkBool32 depthTestEnable;
3148 memcpy((VkBool32*)&depthTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
3149 *readStreamPtrPtr += sizeof(VkBool32);
3150 if (CC_LIKELY(vk)) {
3151 vk->vkCmdSetDepthTestEnableEXT((VkCommandBuffer)dispatchHandle,
3152 depthTestEnable);
3153 }
3154 break;
3155 }
3156 case OP_vkCmdSetDepthWriteEnableEXT: {
3157 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3158 "VkSubDecoder vkCmdSetDepthWriteEnableEXT");
3159 VkBool32 depthWriteEnable;
3160 memcpy((VkBool32*)&depthWriteEnable, *readStreamPtrPtr, sizeof(VkBool32));
3161 *readStreamPtrPtr += sizeof(VkBool32);
3162 if (CC_LIKELY(vk)) {
3163 vk->vkCmdSetDepthWriteEnableEXT((VkCommandBuffer)dispatchHandle,
3164 depthWriteEnable);
3165 }
3166 break;
3167 }
3168 case OP_vkCmdSetDepthCompareOpEXT: {
3169 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3170 "VkSubDecoder vkCmdSetDepthCompareOpEXT");
3171 VkCompareOp depthCompareOp;
3172 memcpy((VkCompareOp*)&depthCompareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
3173 *readStreamPtrPtr += sizeof(VkCompareOp);
3174 if (CC_LIKELY(vk)) {
3175 vk->vkCmdSetDepthCompareOpEXT((VkCommandBuffer)dispatchHandle, depthCompareOp);
3176 }
3177 break;
3178 }
3179 case OP_vkCmdSetDepthBoundsTestEnableEXT: {
3180 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3181 "VkSubDecoder vkCmdSetDepthBoundsTestEnableEXT");
3182 VkBool32 depthBoundsTestEnable;
3183 memcpy((VkBool32*)&depthBoundsTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
3184 *readStreamPtrPtr += sizeof(VkBool32);
3185 if (CC_LIKELY(vk)) {
3186 vk->vkCmdSetDepthBoundsTestEnableEXT((VkCommandBuffer)dispatchHandle,
3187 depthBoundsTestEnable);
3188 }
3189 break;
3190 }
3191 case OP_vkCmdSetStencilTestEnableEXT: {
3192 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3193 "VkSubDecoder vkCmdSetStencilTestEnableEXT");
3194 VkBool32 stencilTestEnable;
3195 memcpy((VkBool32*)&stencilTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
3196 *readStreamPtrPtr += sizeof(VkBool32);
3197 if (CC_LIKELY(vk)) {
3198 vk->vkCmdSetStencilTestEnableEXT((VkCommandBuffer)dispatchHandle,
3199 stencilTestEnable);
3200 }
3201 break;
3202 }
3203 case OP_vkCmdSetStencilOpEXT: {
3204 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3205 "VkSubDecoder vkCmdSetStencilOpEXT");
3206 VkStencilFaceFlags faceMask;
3207 VkStencilOp failOp;
3208 VkStencilOp passOp;
3209 VkStencilOp depthFailOp;
3210 VkCompareOp compareOp;
3211 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
3212 sizeof(VkStencilFaceFlags));
3213 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
3214 memcpy((VkStencilOp*)&failOp, *readStreamPtrPtr, sizeof(VkStencilOp));
3215 *readStreamPtrPtr += sizeof(VkStencilOp);
3216 memcpy((VkStencilOp*)&passOp, *readStreamPtrPtr, sizeof(VkStencilOp));
3217 *readStreamPtrPtr += sizeof(VkStencilOp);
3218 memcpy((VkStencilOp*)&depthFailOp, *readStreamPtrPtr, sizeof(VkStencilOp));
3219 *readStreamPtrPtr += sizeof(VkStencilOp);
3220 memcpy((VkCompareOp*)&compareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
3221 *readStreamPtrPtr += sizeof(VkCompareOp);
3222 if (CC_LIKELY(vk)) {
3223 vk->vkCmdSetStencilOpEXT((VkCommandBuffer)dispatchHandle, faceMask, failOp,
3224 passOp, depthFailOp, compareOp);
3225 }
3226 break;
3227 }
3228 #endif
3229 #ifdef VK_EXT_extended_dynamic_state2
3230 case OP_vkCmdSetPatchControlPointsEXT: {
3231 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3232 "VkSubDecoder vkCmdSetPatchControlPointsEXT");
3233 uint32_t patchControlPoints;
3234 memcpy((uint32_t*)&patchControlPoints, *readStreamPtrPtr, sizeof(uint32_t));
3235 *readStreamPtrPtr += sizeof(uint32_t);
3236 if (CC_LIKELY(vk)) {
3237 vk->vkCmdSetPatchControlPointsEXT((VkCommandBuffer)dispatchHandle,
3238 patchControlPoints);
3239 }
3240 break;
3241 }
3242 case OP_vkCmdSetRasterizerDiscardEnableEXT: {
3243 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3244 "VkSubDecoder vkCmdSetRasterizerDiscardEnableEXT");
3245 VkBool32 rasterizerDiscardEnable;
3246 memcpy((VkBool32*)&rasterizerDiscardEnable, *readStreamPtrPtr, sizeof(VkBool32));
3247 *readStreamPtrPtr += sizeof(VkBool32);
3248 if (CC_LIKELY(vk)) {
3249 vk->vkCmdSetRasterizerDiscardEnableEXT((VkCommandBuffer)dispatchHandle,
3250 rasterizerDiscardEnable);
3251 }
3252 break;
3253 }
3254 case OP_vkCmdSetDepthBiasEnableEXT: {
3255 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3256 "VkSubDecoder vkCmdSetDepthBiasEnableEXT");
3257 VkBool32 depthBiasEnable;
3258 memcpy((VkBool32*)&depthBiasEnable, *readStreamPtrPtr, sizeof(VkBool32));
3259 *readStreamPtrPtr += sizeof(VkBool32);
3260 if (CC_LIKELY(vk)) {
3261 vk->vkCmdSetDepthBiasEnableEXT((VkCommandBuffer)dispatchHandle,
3262 depthBiasEnable);
3263 }
3264 break;
3265 }
3266 case OP_vkCmdSetLogicOpEXT: {
3267 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3268 "VkSubDecoder vkCmdSetLogicOpEXT");
3269 VkLogicOp logicOp;
3270 memcpy((VkLogicOp*)&logicOp, *readStreamPtrPtr, sizeof(VkLogicOp));
3271 *readStreamPtrPtr += sizeof(VkLogicOp);
3272 if (CC_LIKELY(vk)) {
3273 vk->vkCmdSetLogicOpEXT((VkCommandBuffer)dispatchHandle, logicOp);
3274 }
3275 break;
3276 }
3277 case OP_vkCmdSetPrimitiveRestartEnableEXT: {
3278 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3279 "VkSubDecoder vkCmdSetPrimitiveRestartEnableEXT");
3280 VkBool32 primitiveRestartEnable;
3281 memcpy((VkBool32*)&primitiveRestartEnable, *readStreamPtrPtr, sizeof(VkBool32));
3282 *readStreamPtrPtr += sizeof(VkBool32);
3283 if (CC_LIKELY(vk)) {
3284 vk->vkCmdSetPrimitiveRestartEnableEXT((VkCommandBuffer)dispatchHandle,
3285 primitiveRestartEnable);
3286 }
3287 break;
3288 }
3289 #endif
3290 #ifdef VK_EXT_color_write_enable
3291 case OP_vkCmdSetColorWriteEnableEXT: {
3292 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3293 "VkSubDecoder vkCmdSetColorWriteEnableEXT");
3294 uint32_t attachmentCount;
3295 const VkBool32* pColorWriteEnables;
3296 VkBool32 stack_pColorWriteEnables[MAX_STACK_ITEMS];
3297 memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
3298 *readStreamPtrPtr += sizeof(uint32_t);
3299 if (((attachmentCount)) <= MAX_STACK_ITEMS) {
3300 pColorWriteEnables = (VkBool32*)stack_pColorWriteEnables;
3301 } else {
3302 readStream->alloc((void**)&pColorWriteEnables,
3303 ((attachmentCount)) * sizeof(const VkBool32));
3304 }
3305 memcpy((VkBool32*)pColorWriteEnables, *readStreamPtrPtr,
3306 ((attachmentCount)) * sizeof(const VkBool32));
3307 *readStreamPtrPtr += ((attachmentCount)) * sizeof(const VkBool32);
3308 if (CC_LIKELY(vk)) {
3309 vk->vkCmdSetColorWriteEnableEXT((VkCommandBuffer)dispatchHandle,
3310 attachmentCount, pColorWriteEnables);
3311 }
3312 break;
3313 }
3314 #endif
3315 #ifdef VK_GOOGLE_gfxstream
3316 case OP_vkBeginCommandBufferAsyncGOOGLE: {
3317 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3318 "VkSubDecoder vkBeginCommandBufferAsyncGOOGLE");
3319 const VkCommandBufferBeginInfo* pBeginInfo;
3320 VkCommandBufferBeginInfo stack_pBeginInfo[1];
3321 pBeginInfo = (VkCommandBufferBeginInfo*)stack_pBeginInfo;
3322 reservedunmarshal_VkCommandBufferBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3323 (VkCommandBufferBeginInfo*)(pBeginInfo),
3324 readStreamPtrPtr);
3325 if (pBeginInfo) {
3326 transform_tohost_VkCommandBufferBeginInfo(
3327 globalstate, (VkCommandBufferBeginInfo*)(pBeginInfo));
3328 }
3329 if (CC_LIKELY(vk)) {
3330 this->on_vkBeginCommandBufferAsyncGOOGLE(
3331 pool, nullptr, (VkCommandBuffer)(boxed_dispatchHandle), pBeginInfo,
3332 context);
3333 }
3334 break;
3335 }
3336 case OP_vkEndCommandBufferAsyncGOOGLE: {
3337 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3338 "VkSubDecoder vkEndCommandBufferAsyncGOOGLE");
3339 if (CC_LIKELY(vk)) {
3340 this->on_vkEndCommandBufferAsyncGOOGLE(
3341 pool, nullptr, (VkCommandBuffer)(boxed_dispatchHandle), context);
3342 }
3343 break;
3344 }
3345 case OP_vkResetCommandBufferAsyncGOOGLE: {
3346 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3347 "VkSubDecoder vkResetCommandBufferAsyncGOOGLE");
3348 VkCommandBufferResetFlags flags;
3349 memcpy((VkCommandBufferResetFlags*)&flags, *readStreamPtrPtr,
3350 sizeof(VkCommandBufferResetFlags));
3351 *readStreamPtrPtr += sizeof(VkCommandBufferResetFlags);
3352 if (CC_LIKELY(vk)) {
3353 this->on_vkResetCommandBufferAsyncGOOGLE(
3354 pool, nullptr, (VkCommandBuffer)(boxed_dispatchHandle), flags);
3355 }
3356 break;
3357 }
3358 case OP_vkCommandBufferHostSyncGOOGLE: {
3359 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3360 "VkSubDecoder vkCommandBufferHostSyncGOOGLE");
3361 uint32_t needHostSync;
3362 uint32_t sequenceNumber;
3363 memcpy((uint32_t*)&needHostSync, *readStreamPtrPtr, sizeof(uint32_t));
3364 *readStreamPtrPtr += sizeof(uint32_t);
3365 memcpy((uint32_t*)&sequenceNumber, *readStreamPtrPtr, sizeof(uint32_t));
3366 *readStreamPtrPtr += sizeof(uint32_t);
3367 if (CC_LIKELY(vk)) {
3368 this->on_vkCommandBufferHostSyncGOOGLE(pool, nullptr,
3369 (VkCommandBuffer)(boxed_dispatchHandle),
3370 needHostSync, sequenceNumber);
3371 }
3372 break;
3373 }
3374 #endif
3375 #ifdef VK_KHR_ray_tracing_pipeline
3376 case OP_vkCmdTraceRaysKHR: {
3377 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3378 "VkSubDecoder vkCmdTraceRaysKHR");
3379 const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable;
3380 VkStridedDeviceAddressRegionKHR stack_pRaygenShaderBindingTable[1];
3381 const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable;
3382 VkStridedDeviceAddressRegionKHR stack_pMissShaderBindingTable[1];
3383 const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable;
3384 VkStridedDeviceAddressRegionKHR stack_pHitShaderBindingTable[1];
3385 const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable;
3386 VkStridedDeviceAddressRegionKHR stack_pCallableShaderBindingTable[1];
3387 uint32_t width;
3388 uint32_t height;
3389 uint32_t depth;
3390 pRaygenShaderBindingTable =
3391 (VkStridedDeviceAddressRegionKHR*)stack_pRaygenShaderBindingTable;
3392 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
3393 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3394 (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable),
3395 readStreamPtrPtr);
3396 pMissShaderBindingTable =
3397 (VkStridedDeviceAddressRegionKHR*)stack_pMissShaderBindingTable;
3398 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
3399 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3400 (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable), readStreamPtrPtr);
3401 pHitShaderBindingTable =
3402 (VkStridedDeviceAddressRegionKHR*)stack_pHitShaderBindingTable;
3403 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
3404 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3405 (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable), readStreamPtrPtr);
3406 pCallableShaderBindingTable =
3407 (VkStridedDeviceAddressRegionKHR*)stack_pCallableShaderBindingTable;
3408 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
3409 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3410 (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable),
3411 readStreamPtrPtr);
3412 memcpy((uint32_t*)&width, *readStreamPtrPtr, sizeof(uint32_t));
3413 *readStreamPtrPtr += sizeof(uint32_t);
3414 memcpy((uint32_t*)&height, *readStreamPtrPtr, sizeof(uint32_t));
3415 *readStreamPtrPtr += sizeof(uint32_t);
3416 memcpy((uint32_t*)&depth, *readStreamPtrPtr, sizeof(uint32_t));
3417 *readStreamPtrPtr += sizeof(uint32_t);
3418 if (pRaygenShaderBindingTable) {
3419 transform_tohost_VkStridedDeviceAddressRegionKHR(
3420 globalstate, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable));
3421 }
3422 if (pMissShaderBindingTable) {
3423 transform_tohost_VkStridedDeviceAddressRegionKHR(
3424 globalstate, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable));
3425 }
3426 if (pHitShaderBindingTable) {
3427 transform_tohost_VkStridedDeviceAddressRegionKHR(
3428 globalstate, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable));
3429 }
3430 if (pCallableShaderBindingTable) {
3431 transform_tohost_VkStridedDeviceAddressRegionKHR(
3432 globalstate,
3433 (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable));
3434 }
3435 if (CC_LIKELY(vk)) {
3436 vk->vkCmdTraceRaysKHR((VkCommandBuffer)dispatchHandle,
3437 pRaygenShaderBindingTable, pMissShaderBindingTable,
3438 pHitShaderBindingTable, pCallableShaderBindingTable,
3439 width, height, depth);
3440 }
3441 break;
3442 }
3443 case OP_vkCmdTraceRaysIndirectKHR: {
3444 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3445 "VkSubDecoder vkCmdTraceRaysIndirectKHR");
3446 const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable;
3447 VkStridedDeviceAddressRegionKHR stack_pRaygenShaderBindingTable[1];
3448 const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable;
3449 VkStridedDeviceAddressRegionKHR stack_pMissShaderBindingTable[1];
3450 const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable;
3451 VkStridedDeviceAddressRegionKHR stack_pHitShaderBindingTable[1];
3452 const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable;
3453 VkStridedDeviceAddressRegionKHR stack_pCallableShaderBindingTable[1];
3454 VkDeviceAddress indirectDeviceAddress;
3455 pRaygenShaderBindingTable =
3456 (VkStridedDeviceAddressRegionKHR*)stack_pRaygenShaderBindingTable;
3457 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
3458 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3459 (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable),
3460 readStreamPtrPtr);
3461 pMissShaderBindingTable =
3462 (VkStridedDeviceAddressRegionKHR*)stack_pMissShaderBindingTable;
3463 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
3464 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3465 (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable), readStreamPtrPtr);
3466 pHitShaderBindingTable =
3467 (VkStridedDeviceAddressRegionKHR*)stack_pHitShaderBindingTable;
3468 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
3469 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3470 (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable), readStreamPtrPtr);
3471 pCallableShaderBindingTable =
3472 (VkStridedDeviceAddressRegionKHR*)stack_pCallableShaderBindingTable;
3473 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
3474 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3475 (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable),
3476 readStreamPtrPtr);
3477 memcpy((VkDeviceAddress*)&indirectDeviceAddress, *readStreamPtrPtr,
3478 sizeof(VkDeviceAddress));
3479 *readStreamPtrPtr += sizeof(VkDeviceAddress);
3480 if (pRaygenShaderBindingTable) {
3481 transform_tohost_VkStridedDeviceAddressRegionKHR(
3482 globalstate, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable));
3483 }
3484 if (pMissShaderBindingTable) {
3485 transform_tohost_VkStridedDeviceAddressRegionKHR(
3486 globalstate, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable));
3487 }
3488 if (pHitShaderBindingTable) {
3489 transform_tohost_VkStridedDeviceAddressRegionKHR(
3490 globalstate, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable));
3491 }
3492 if (pCallableShaderBindingTable) {
3493 transform_tohost_VkStridedDeviceAddressRegionKHR(
3494 globalstate,
3495 (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable));
3496 }
3497 if (CC_LIKELY(vk)) {
3498 vk->vkCmdTraceRaysIndirectKHR(
3499 (VkCommandBuffer)dispatchHandle, pRaygenShaderBindingTable,
3500 pMissShaderBindingTable, pHitShaderBindingTable,
3501 pCallableShaderBindingTable, indirectDeviceAddress);
3502 }
3503 break;
3504 }
3505 case OP_vkCmdSetRayTracingPipelineStackSizeKHR: {
3506 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3507 "VkSubDecoder vkCmdSetRayTracingPipelineStackSizeKHR");
3508 uint32_t pipelineStackSize;
3509 memcpy((uint32_t*)&pipelineStackSize, *readStreamPtrPtr, sizeof(uint32_t));
3510 *readStreamPtrPtr += sizeof(uint32_t);
3511 if (CC_LIKELY(vk)) {
3512 vk->vkCmdSetRayTracingPipelineStackSizeKHR((VkCommandBuffer)dispatchHandle,
3513 pipelineStackSize);
3514 }
3515 break;
3516 }
3517 #endif
3518 default: {
3519 GFXSTREAM_ABORT(::emugl::FatalError(::emugl::ABORT_REASON_OTHER))
3520 << "Unrecognized opcode " << opcode;
3521 }
3522 }
3523 ++count;
3524 if (count % 1000 == 0) {
3525 pool->freeAll();
3526 };
3527 ptr += packetLen;
3528 }
3529 pool->freeAll();
3530 return ptr - (unsigned char*)buf;
3531 ;
3532 }
3533