Add extensions used in test applications
Add VK_KHR_ray_tracing_pipeline and VK_KHR_pipeline_library
extensions support which are used by some test applications.
Bug: 351729443
Test: run benchmark tests on MacOS
Change-Id: Ice76fbc1b431b6ee74b8df587719fe4f13f457a8
diff --git a/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py b/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
index 720d218..af73410 100644
--- a/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
+++ b/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
@@ -124,6 +124,8 @@
"VK_KHR_external_semaphore_win32",
"VK_KHR_external_memory_win32",
"VK_NV_device_diagnostic_checkpoints",
+ "VK_KHR_ray_tracing_pipeline",
+ "VK_KHR_pipeline_library",
# Android
"VK_ANDROID_native_buffer",
"VK_ANDROID_external_memory_android_hardware_buffer",
@@ -171,6 +173,8 @@
"VK_EXT_swapchain_maintenance1" : HOST_MODULES,
"VK_KHR_swapchain" : HOST_MODULES,
"VK_NV_device_diagnostic_checkpoints": ["goldfish_vk_dispatch"],
+ "VK_KHR_ray_tracing_pipeline": HOST_MODULES,
+ "VK_KHR_pipeline_library": HOST_MODULES,
}
# These modules will be used when the feature is not supported.
diff --git a/guest/vulkan_enc/vulkan_gfxstream.h b/guest/vulkan_enc/vulkan_gfxstream.h
index 013f6a8..a7ac22b 100644
--- a/guest/vulkan_enc/vulkan_gfxstream.h
+++ b/guest/vulkan_enc/vulkan_gfxstream.h
@@ -69,8 +69,7 @@
typedef VkResult (VKAPI_PTR *PFN_vkGetBlobGOOGLE)(VkDevice device, VkDeviceMemory memory);
typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateSized2GOOGLE)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount, uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount, const uint32_t* pImageInfoEntryIndices, const uint32_t* pBufferInfoEntryIndices, const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews, const uint8_t* pInlineUniformBlockData);
typedef void (VKAPI_PTR *PFN_vkQueueSubmitAsync2GOOGLE)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence);
-typedef VkResult(VKAPI_PTR* PFN_vkGetSemaphoreGOOGLE)(VkDevice device, VkSemaphore semaphore,
- uint64_t guestHandleTypes, uint64_t syncId);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreGOOGLE)(VkDevice device, VkSemaphore semaphore, uint64_t syncId);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkMapMemoryIntoAddressSpaceGOOGLE(
@@ -230,8 +229,10 @@
const VkSubmitInfo2* pSubmits,
VkFence fence);
-VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreGOOGLE(VkDevice device, VkSemaphore semaphore,
- uint64_t guestHandleTypes, uint64_t syncId);
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreGOOGLE(
+ VkDevice device,
+ VkSemaphore semaphore,
+ uint64_t syncId);
#endif
#ifdef __cplusplus
diff --git a/host/vulkan/VkDecoder.cpp b/host/vulkan/VkDecoder.cpp
index 5321b02..ac7f042 100644
--- a/host/vulkan/VkDecoder.cpp
+++ b/host/vulkan/VkDecoder.cpp
@@ -22119,6 +22119,466 @@
break;
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ case OP_vkCmdTraceRaysKHR: {
+ android::base::beginTrace("vkCmdTraceRaysKHR decode");
+ VkCommandBuffer commandBuffer;
+ const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable;
+ const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable;
+ const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable;
+ const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable;
+ uint32_t width;
+ uint32_t height;
+ uint32_t depth;
+ // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkCommandBuffer*)&commandBuffer =
+ (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+ auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+ auto vk = dispatch_VkCommandBuffer(commandBuffer);
+ // End manual dispatchable handle unboxing for commandBuffer;
+ vkReadStream->alloc((void**)&pRaygenShaderBindingTable,
+ sizeof(const VkStridedDeviceAddressRegionKHR));
+ reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable),
+ readStreamPtrPtr);
+ vkReadStream->alloc((void**)&pMissShaderBindingTable,
+ sizeof(const VkStridedDeviceAddressRegionKHR));
+ reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable), readStreamPtrPtr);
+ vkReadStream->alloc((void**)&pHitShaderBindingTable,
+ sizeof(const VkStridedDeviceAddressRegionKHR));
+ reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable), readStreamPtrPtr);
+ vkReadStream->alloc((void**)&pCallableShaderBindingTable,
+ sizeof(const VkStridedDeviceAddressRegionKHR));
+ reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable),
+ readStreamPtrPtr);
+ memcpy((uint32_t*)&width, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&height, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&depth, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (pRaygenShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ m_state, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable));
+ }
+ if (pMissShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ m_state, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable));
+ }
+ if (pHitShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ m_state, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable));
+ }
+ if (pCallableShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ m_state, (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable));
+ }
+ if (m_logCalls) {
+ fprintf(stderr,
+ "stream %p: call vkCmdTraceRaysKHR 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx "
+ "0x%llx 0x%llx 0x%llx \n",
+ ioStream, (unsigned long long)commandBuffer,
+ (unsigned long long)pRaygenShaderBindingTable,
+ (unsigned long long)pMissShaderBindingTable,
+ (unsigned long long)pHitShaderBindingTable,
+ (unsigned long long)pCallableShaderBindingTable,
+ (unsigned long long)width, (unsigned long long)height,
+ (unsigned long long)depth);
+ }
+ vk->vkCmdTraceRaysKHR(unboxed_commandBuffer, pRaygenShaderBindingTable,
+ pMissShaderBindingTable, pHitShaderBindingTable,
+ pCallableShaderBindingTable, width, height, depth);
+ vkStream->unsetHandleMapping();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkCmdTraceRaysKHR(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+ pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable,
+ pCallableShaderBindingTable, width, height, depth);
+ }
+ vkReadStream->clearPool();
+ if (m_queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCreateRayTracingPipelinesKHR: {
+ android::base::beginTrace("vkCreateRayTracingPipelinesKHR decode");
+ VkDevice device;
+ VkDeferredOperationKHR deferredOperation;
+ VkPipelineCache pipelineCache;
+ uint32_t createInfoCount;
+ const VkRayTracingPipelineCreateInfoKHR* pCreateInfos;
+ const VkAllocationCallbacks* pAllocator;
+ VkPipeline* pPipelines;
+ // Begin non wrapped dispatchable handle unboxing for device;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+ auto unboxed_device = unbox_VkDevice(device);
+ auto vk = dispatch_VkDevice(device);
+ // End manual dispatchable handle unboxing for device;
+ memcpy((VkDeferredOperationKHR*)&deferredOperation, (*readStreamPtrPtr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&deferredOperation);
+ *readStreamPtrPtr += 8;
+ uint64_t cgen_var_2;
+ memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkPipelineCache*)&pipelineCache =
+ (VkPipelineCache)unbox_VkPipelineCache((VkPipelineCache)(*&cgen_var_2));
+ memcpy((uint32_t*)&createInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ vkReadStream->alloc(
+ (void**)&pCreateInfos,
+ ((createInfoCount)) * sizeof(const VkRayTracingPipelineCreateInfoKHR));
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ reservedunmarshal_VkRayTracingPipelineCreateInfoKHR(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRayTracingPipelineCreateInfoKHR*)(pCreateInfos + i), readStreamPtrPtr);
+ }
+ // WARNING PTR CHECK
+ memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&pAllocator);
+ *readStreamPtrPtr += 8;
+ if (pAllocator) {
+ vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
+ reservedunmarshal_VkAllocationCallbacks(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
+ }
+ // Begin manual dispatchable handle unboxing for pPipelines;
+ vkReadStream->unsetHandleMapping();
+ vkReadStream->alloc((void**)&pPipelines, ((createInfoCount)) * sizeof(VkPipeline));
+ if (((createInfoCount))) {
+ uint8_t* cgen_var_4_ptr = (uint8_t*)(*readStreamPtrPtr);
+ *readStreamPtrPtr += 8 * ((createInfoCount));
+ for (uint32_t k = 0; k < ((createInfoCount)); ++k) {
+ uint64_t tmpval;
+ memcpy(&tmpval, cgen_var_4_ptr + k * 8, sizeof(uint64_t));
+ *(((VkPipeline*)pPipelines) + k) =
+ (VkPipeline)(VkPipeline)((VkPipeline)tmpval);
+ }
+ }
+ if (pCreateInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ transform_tohost_VkRayTracingPipelineCreateInfoKHR(
+ m_state, (VkRayTracingPipelineCreateInfoKHR*)(pCreateInfos + i));
+ }
+ }
+ if (pAllocator) {
+ transform_tohost_VkAllocationCallbacks(m_state,
+ (VkAllocationCallbacks*)(pAllocator));
+ }
+ if (m_logCalls) {
+ fprintf(stderr,
+ "stream %p: call vkCreateRayTracingPipelinesKHR 0x%llx 0x%llx 0x%llx "
+ "0x%llx 0x%llx 0x%llx 0x%llx \n",
+ ioStream, (unsigned long long)device,
+ (unsigned long long)deferredOperation,
+ (unsigned long long)pipelineCache, (unsigned long long)createInfoCount,
+ (unsigned long long)pCreateInfos, (unsigned long long)pAllocator,
+ (unsigned long long)pPipelines);
+ }
+ VkResult vkCreateRayTracingPipelinesKHR_VkResult_return = (VkResult)0;
+ vkCreateRayTracingPipelinesKHR_VkResult_return = vk->vkCreateRayTracingPipelinesKHR(
+ unboxed_device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos,
+ pAllocator, pPipelines);
+ if ((vkCreateRayTracingPipelinesKHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
+ m_state->on_DeviceLost();
+ m_state->on_CheckOutOfMemory(vkCreateRayTracingPipelinesKHR_VkResult_return, opcode,
+ context);
+ vkStream->unsetHandleMapping();
+ if (((createInfoCount))) {
+ uint64_t* cgen_var_5;
+ vkStream->alloc((void**)&cgen_var_5, ((createInfoCount)) * 8);
+ vkStream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_5,
+ ((createInfoCount)));
+ vkStream->write((uint64_t*)cgen_var_5, ((createInfoCount)) * 8);
+ }
+ vkStream->write(&vkCreateRayTracingPipelinesKHR_VkResult_return, sizeof(VkResult));
+ vkStream->commitWrite();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkCreateRayTracingPipelinesKHR(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+ vkCreateRayTracingPipelinesKHR_VkResult_return, device, deferredOperation,
+ pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+ }
+ vkReadStream->clearPool();
+ if (m_queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR: {
+ android::base::beginTrace(
+ "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR decode");
+ VkDevice device;
+ VkPipeline pipeline;
+ uint32_t firstGroup;
+ uint32_t groupCount;
+ size_t dataSize;
+ void* pData;
+ // Begin non wrapped dispatchable handle unboxing for device;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+ auto unboxed_device = unbox_VkDevice(device);
+ auto vk = dispatch_VkDevice(device);
+ // End manual dispatchable handle unboxing for device;
+ uint64_t cgen_var_1;
+ memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkPipeline*)&pipeline = (VkPipeline)unbox_VkPipeline((VkPipeline)(*&cgen_var_1));
+ memcpy((uint32_t*)&firstGroup, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&groupCount, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((size_t*)&dataSize, (*readStreamPtrPtr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&dataSize);
+ *readStreamPtrPtr += 8;
+ // Begin manual dispatchable handle unboxing for pData;
+ vkReadStream->unsetHandleMapping();
+ vkReadStream->alloc((void**)&pData, ((dataSize)) * sizeof(uint8_t));
+ memcpy((void*)pData, *readStreamPtrPtr, ((dataSize)) * sizeof(uint8_t));
+ *readStreamPtrPtr += ((dataSize)) * sizeof(uint8_t);
+ if (m_logCalls) {
+ fprintf(stderr,
+ "stream %p: call vkGetRayTracingCaptureReplayShaderGroupHandlesKHR "
+ "0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
+ ioStream, (unsigned long long)device, (unsigned long long)pipeline,
+ (unsigned long long)firstGroup, (unsigned long long)groupCount,
+ (unsigned long long)dataSize, (unsigned long long)pData);
+ }
+ VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return =
+ (VkResult)0;
+ vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return =
+ vk->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
+ unboxed_device, pipeline, firstGroup, groupCount, dataSize, pData);
+ if ((vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return) ==
+ VK_ERROR_DEVICE_LOST)
+ m_state->on_DeviceLost();
+ m_state->on_CheckOutOfMemory(
+ vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return, opcode,
+ context);
+ vkStream->unsetHandleMapping();
+ vkStream->write((void*)pData, ((dataSize)) * sizeof(uint8_t));
+ vkStream->write(&vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return,
+ sizeof(VkResult));
+ vkStream->commitWrite();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+ vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return, device,
+ pipeline, firstGroup, groupCount, dataSize, pData);
+ }
+ vkReadStream->clearPool();
+ if (m_queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdTraceRaysIndirectKHR: {
+ android::base::beginTrace("vkCmdTraceRaysIndirectKHR decode");
+ VkCommandBuffer commandBuffer;
+ const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable;
+ const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable;
+ const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable;
+ const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable;
+ VkDeviceAddress indirectDeviceAddress;
+ // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkCommandBuffer*)&commandBuffer =
+ (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+ auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+ auto vk = dispatch_VkCommandBuffer(commandBuffer);
+ // End manual dispatchable handle unboxing for commandBuffer;
+ vkReadStream->alloc((void**)&pRaygenShaderBindingTable,
+ sizeof(const VkStridedDeviceAddressRegionKHR));
+ reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable),
+ readStreamPtrPtr);
+ vkReadStream->alloc((void**)&pMissShaderBindingTable,
+ sizeof(const VkStridedDeviceAddressRegionKHR));
+ reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable), readStreamPtrPtr);
+ vkReadStream->alloc((void**)&pHitShaderBindingTable,
+ sizeof(const VkStridedDeviceAddressRegionKHR));
+ reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable), readStreamPtrPtr);
+ vkReadStream->alloc((void**)&pCallableShaderBindingTable,
+ sizeof(const VkStridedDeviceAddressRegionKHR));
+ reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable),
+ readStreamPtrPtr);
+ memcpy((VkDeviceAddress*)&indirectDeviceAddress, *readStreamPtrPtr,
+ sizeof(VkDeviceAddress));
+ *readStreamPtrPtr += sizeof(VkDeviceAddress);
+ if (pRaygenShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ m_state, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable));
+ }
+ if (pMissShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ m_state, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable));
+ }
+ if (pHitShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ m_state, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable));
+ }
+ if (pCallableShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ m_state, (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable));
+ }
+ if (m_logCalls) {
+ fprintf(stderr,
+ "stream %p: call vkCmdTraceRaysIndirectKHR 0x%llx 0x%llx 0x%llx 0x%llx "
+ "0x%llx 0x%llx \n",
+ ioStream, (unsigned long long)commandBuffer,
+ (unsigned long long)pRaygenShaderBindingTable,
+ (unsigned long long)pMissShaderBindingTable,
+ (unsigned long long)pHitShaderBindingTable,
+ (unsigned long long)pCallableShaderBindingTable,
+ (unsigned long long)indirectDeviceAddress);
+ }
+ vk->vkCmdTraceRaysIndirectKHR(unboxed_commandBuffer, pRaygenShaderBindingTable,
+ pMissShaderBindingTable, pHitShaderBindingTable,
+ pCallableShaderBindingTable, indirectDeviceAddress);
+ vkStream->unsetHandleMapping();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkCmdTraceRaysIndirectKHR(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+ pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable,
+ pCallableShaderBindingTable, indirectDeviceAddress);
+ }
+ vkReadStream->clearPool();
+ if (m_queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkGetRayTracingShaderGroupStackSizeKHR: {
+ android::base::beginTrace("vkGetRayTracingShaderGroupStackSizeKHR decode");
+ VkDevice device;
+ VkPipeline pipeline;
+ uint32_t group;
+ VkShaderGroupShaderKHR groupShader;
+ // Begin non wrapped dispatchable handle unboxing for device;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+ auto unboxed_device = unbox_VkDevice(device);
+ auto vk = dispatch_VkDevice(device);
+ // End manual dispatchable handle unboxing for device;
+ uint64_t cgen_var_1;
+ memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkPipeline*)&pipeline = (VkPipeline)unbox_VkPipeline((VkPipeline)(*&cgen_var_1));
+ memcpy((uint32_t*)&group, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((VkShaderGroupShaderKHR*)&groupShader, *readStreamPtrPtr,
+ sizeof(VkShaderGroupShaderKHR));
+ *readStreamPtrPtr += sizeof(VkShaderGroupShaderKHR);
+ if (m_logCalls) {
+ fprintf(stderr,
+ "stream %p: call vkGetRayTracingShaderGroupStackSizeKHR 0x%llx 0x%llx "
+ "0x%llx 0x%llx \n",
+ ioStream, (unsigned long long)device, (unsigned long long)pipeline,
+ (unsigned long long)group, (unsigned long long)groupShader);
+ }
+ VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return =
+ (VkDeviceSize)0;
+ vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return =
+ vk->vkGetRayTracingShaderGroupStackSizeKHR(unboxed_device, pipeline, group,
+ groupShader);
+ vkStream->unsetHandleMapping();
+ vkStream->write(&vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return,
+ sizeof(VkDeviceSize));
+ vkStream->commitWrite();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkGetRayTracingShaderGroupStackSizeKHR(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+ vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return, device,
+ pipeline, group, groupShader);
+ }
+ vkReadStream->clearPool();
+ if (m_queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetRayTracingPipelineStackSizeKHR: {
+ android::base::beginTrace("vkCmdSetRayTracingPipelineStackSizeKHR decode");
+ VkCommandBuffer commandBuffer;
+ uint32_t pipelineStackSize;
+ // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkCommandBuffer*)&commandBuffer =
+ (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+ auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+ auto vk = dispatch_VkCommandBuffer(commandBuffer);
+ // End manual dispatchable handle unboxing for commandBuffer;
+ memcpy((uint32_t*)&pipelineStackSize, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (m_logCalls) {
+ fprintf(
+ stderr,
+ "stream %p: call vkCmdSetRayTracingPipelineStackSizeKHR 0x%llx 0x%llx \n",
+ ioStream, (unsigned long long)commandBuffer,
+ (unsigned long long)pipelineStackSize);
+ }
+ vk->vkCmdSetRayTracingPipelineStackSizeKHR(unboxed_commandBuffer,
+ pipelineStackSize);
+ vkStream->unsetHandleMapping();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkCmdSetRayTracingPipelineStackSizeKHR(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+ pipelineStackSize);
+ }
+ vkReadStream->clearPool();
+ if (m_queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+#endif
default: {
m_pool.freeAll();
return ptr - (unsigned char*)buf;
diff --git a/host/vulkan/VkDecoderSnapshot.cpp b/host/vulkan/VkDecoderSnapshot.cpp
index f3881d9..25a024a 100644
--- a/host/vulkan/VkDecoderSnapshot.cpp
+++ b/host/vulkan/VkDecoderSnapshot.cpp
@@ -3738,6 +3738,79 @@
android::base::BumpPool* pool, VkResult input_result, VkDevice device,
VkSemaphore semaphore, uint64_t syncId) {}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ void vkCmdTraceRaysKHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+ const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
+ uint32_t width, uint32_t height, uint32_t depth) {
+ android::base::AutoLock lock(mLock);
+ // commandBuffer modify
+ auto apiHandle = mReconstruction.createApiInfo();
+ auto apiInfo = mReconstruction.getApiInfo(apiHandle);
+ mReconstruction.setApiTrace(apiInfo, OP_vkCmdTraceRaysKHR, snapshotTraceBegin,
+ snapshotTraceBytes);
+ for (uint32_t i = 0; i < 1; ++i) {
+ VkCommandBuffer boxed = unboxed_to_boxed_VkCommandBuffer((&commandBuffer)[i]);
+ mReconstruction.forEachHandleAddModifyApi((const uint64_t*)(&boxed), 1, apiHandle);
+ }
+ }
+ void vkCreateRayTracingPipelinesKHR(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkResult input_result, VkDevice device,
+ VkDeferredOperationKHR deferredOperation,
+ VkPipelineCache pipelineCache, uint32_t createInfoCount,
+ const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines) {}
+ void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
+ const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkResult input_result, VkDevice device, VkPipeline pipeline, uint32_t firstGroup,
+ uint32_t groupCount, size_t dataSize, void* pData) {}
+ void vkCmdTraceRaysIndirectKHR(
+ const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkCommandBuffer commandBuffer,
+ const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
+ VkDeviceAddress indirectDeviceAddress) {
+ android::base::AutoLock lock(mLock);
+ // commandBuffer modify
+ auto apiHandle = mReconstruction.createApiInfo();
+ auto apiInfo = mReconstruction.getApiInfo(apiHandle);
+ mReconstruction.setApiTrace(apiInfo, OP_vkCmdTraceRaysIndirectKHR, snapshotTraceBegin,
+ snapshotTraceBytes);
+ for (uint32_t i = 0; i < 1; ++i) {
+ VkCommandBuffer boxed = unboxed_to_boxed_VkCommandBuffer((&commandBuffer)[i]);
+ mReconstruction.forEachHandleAddModifyApi((const uint64_t*)(&boxed), 1, apiHandle);
+ }
+ }
+ void vkGetRayTracingShaderGroupStackSizeKHR(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes,
+ android::base::BumpPool* pool,
+ VkDeviceSize input_result, VkDevice device,
+ VkPipeline pipeline, uint32_t group,
+ VkShaderGroupShaderKHR groupShader) {}
+ void vkCmdSetRayTracingPipelineStackSizeKHR(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes,
+ android::base::BumpPool* pool,
+ VkCommandBuffer commandBuffer,
+ uint32_t pipelineStackSize) {
+ android::base::AutoLock lock(mLock);
+ // commandBuffer modify
+ auto apiHandle = mReconstruction.createApiInfo();
+ auto apiInfo = mReconstruction.getApiInfo(apiHandle);
+ mReconstruction.setApiTrace(apiInfo, OP_vkCmdSetRayTracingPipelineStackSizeKHR,
+ snapshotTraceBegin, snapshotTraceBytes);
+ for (uint32_t i = 0; i < 1; ++i) {
+ VkCommandBuffer boxed = unboxed_to_boxed_VkCommandBuffer((&commandBuffer)[i]);
+ mReconstruction.forEachHandleAddModifyApi((const uint64_t*)(&boxed), 1, apiHandle);
+ }
+ }
+#endif
private:
android::base::Lock mLock;
VkReconstruction mReconstruction;
@@ -7262,3 +7335,73 @@
semaphore, syncId);
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+void VkDecoderSnapshot::vkCmdTraceRaysKHR(
+ const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width,
+ uint32_t height, uint32_t depth) {
+ mImpl->vkCmdTraceRaysKHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+ pRaygenShaderBindingTable, pMissShaderBindingTable,
+ pHitShaderBindingTable, pCallableShaderBindingTable, width, height,
+ depth);
+}
+#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+void VkDecoderSnapshot::vkCreateRayTracingPipelinesKHR(
+ const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkResult input_result, VkDevice device, VkDeferredOperationKHR deferredOperation,
+ VkPipelineCache pipelineCache, uint32_t createInfoCount,
+ const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines) {
+ mImpl->vkCreateRayTracingPipelinesKHR(snapshotTraceBegin, snapshotTraceBytes, pool,
+ input_result, device, deferredOperation, pipelineCache,
+ createInfoCount, pCreateInfos, pAllocator, pPipelines);
+}
+#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+void VkDecoderSnapshot::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
+ const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkResult input_result, VkDevice device, VkPipeline pipeline, uint32_t firstGroup,
+ uint32_t groupCount, size_t dataSize, void* pData) {
+ mImpl->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
+ snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pipeline, firstGroup,
+ groupCount, dataSize, pData);
+}
+#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+void VkDecoderSnapshot::vkCmdTraceRaysIndirectKHR(
+ const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
+ VkDeviceAddress indirectDeviceAddress) {
+ mImpl->vkCmdTraceRaysIndirectKHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+ pRaygenShaderBindingTable, pMissShaderBindingTable,
+ pHitShaderBindingTable, pCallableShaderBindingTable,
+ indirectDeviceAddress);
+}
+#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+void VkDecoderSnapshot::vkGetRayTracingShaderGroupStackSizeKHR(
+ const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkDeviceSize input_result, VkDevice device, VkPipeline pipeline, uint32_t group,
+ VkShaderGroupShaderKHR groupShader) {
+ mImpl->vkGetRayTracingShaderGroupStackSizeKHR(snapshotTraceBegin, snapshotTraceBytes, pool,
+ input_result, device, pipeline, group,
+ groupShader);
+}
+#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+void VkDecoderSnapshot::vkCmdSetRayTracingPipelineStackSizeKHR(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes,
+ android::base::BumpPool* pool,
+ VkCommandBuffer commandBuffer,
+ uint32_t pipelineStackSize) {
+ mImpl->vkCmdSetRayTracingPipelineStackSizeKHR(snapshotTraceBegin, snapshotTraceBytes, pool,
+ commandBuffer, pipelineStackSize);
+}
+#endif
diff --git a/host/vulkan/VkDecoderSnapshot.h b/host/vulkan/VkDecoderSnapshot.h
index f0c121f..466adc6 100644
--- a/host/vulkan/VkDecoderSnapshot.h
+++ b/host/vulkan/VkDecoderSnapshot.h
@@ -1565,6 +1565,46 @@
android::base::BumpPool* pool, VkResult input_result, VkDevice device,
VkSemaphore semaphore, uint64_t syncId);
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ void vkCmdTraceRaysKHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+ const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
+ uint32_t width, uint32_t height, uint32_t depth);
+ void vkCreateRayTracingPipelinesKHR(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkResult input_result, VkDevice device,
+ VkDeferredOperationKHR deferredOperation,
+ VkPipelineCache pipelineCache, uint32_t createInfoCount,
+ const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+ void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
+ const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkResult input_result, VkDevice device, VkPipeline pipeline, uint32_t firstGroup,
+ uint32_t groupCount, size_t dataSize, void* pData);
+ void vkCmdTraceRaysIndirectKHR(
+ const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkCommandBuffer commandBuffer,
+ const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
+ VkDeviceAddress indirectDeviceAddress);
+ void vkGetRayTracingShaderGroupStackSizeKHR(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes,
+ android::base::BumpPool* pool,
+ VkDeviceSize input_result, VkDevice device,
+ VkPipeline pipeline, uint32_t group,
+ VkShaderGroupShaderKHR groupShader);
+ void vkCmdSetRayTracingPipelineStackSizeKHR(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes,
+ android::base::BumpPool* pool,
+ VkCommandBuffer commandBuffer,
+ uint32_t pipelineStackSize);
+#endif
private:
class Impl;
std::unique_ptr<Impl> mImpl;
diff --git a/host/vulkan/VkSubDecoder.cpp b/host/vulkan/VkSubDecoder.cpp
index 9d64757..276aff9 100644
--- a/host/vulkan/VkSubDecoder.cpp
+++ b/host/vulkan/VkSubDecoder.cpp
@@ -3054,6 +3054,142 @@
break;
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ case OP_vkCmdTraceRaysKHR: {
+ android::base::beginTrace("vkCmdTraceRaysKHR subdecode");
+ const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable;
+ VkStridedDeviceAddressRegionKHR stack_pRaygenShaderBindingTable[1];
+ const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable;
+ VkStridedDeviceAddressRegionKHR stack_pMissShaderBindingTable[1];
+ const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable;
+ VkStridedDeviceAddressRegionKHR stack_pHitShaderBindingTable[1];
+ const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable;
+ VkStridedDeviceAddressRegionKHR stack_pCallableShaderBindingTable[1];
+ uint32_t width;
+ uint32_t height;
+ uint32_t depth;
+ pRaygenShaderBindingTable =
+ (VkStridedDeviceAddressRegionKHR*)stack_pRaygenShaderBindingTable;
+ reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable),
+ readStreamPtrPtr);
+ pMissShaderBindingTable =
+ (VkStridedDeviceAddressRegionKHR*)stack_pMissShaderBindingTable;
+ reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable), readStreamPtrPtr);
+ pHitShaderBindingTable =
+ (VkStridedDeviceAddressRegionKHR*)stack_pHitShaderBindingTable;
+ reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable), readStreamPtrPtr);
+ pCallableShaderBindingTable =
+ (VkStridedDeviceAddressRegionKHR*)stack_pCallableShaderBindingTable;
+ reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable),
+ readStreamPtrPtr);
+ memcpy((uint32_t*)&width, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&height, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ memcpy((uint32_t*)&depth, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ if (pRaygenShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ globalstate, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable));
+ }
+ if (pMissShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ globalstate, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable));
+ }
+ if (pHitShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ globalstate, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable));
+ }
+ if (pCallableShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ globalstate,
+ (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable));
+ }
+ vk->vkCmdTraceRaysKHR((VkCommandBuffer)dispatchHandle, pRaygenShaderBindingTable,
+ pMissShaderBindingTable, pHitShaderBindingTable,
+ pCallableShaderBindingTable, width, height, depth);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdTraceRaysIndirectKHR: {
+ android::base::beginTrace("vkCmdTraceRaysIndirectKHR subdecode");
+ const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable;
+ VkStridedDeviceAddressRegionKHR stack_pRaygenShaderBindingTable[1];
+ const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable;
+ VkStridedDeviceAddressRegionKHR stack_pMissShaderBindingTable[1];
+ const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable;
+ VkStridedDeviceAddressRegionKHR stack_pHitShaderBindingTable[1];
+ const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable;
+ VkStridedDeviceAddressRegionKHR stack_pCallableShaderBindingTable[1];
+ VkDeviceAddress indirectDeviceAddress;
+ pRaygenShaderBindingTable =
+ (VkStridedDeviceAddressRegionKHR*)stack_pRaygenShaderBindingTable;
+ reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable),
+ readStreamPtrPtr);
+ pMissShaderBindingTable =
+ (VkStridedDeviceAddressRegionKHR*)stack_pMissShaderBindingTable;
+ reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable), readStreamPtrPtr);
+ pHitShaderBindingTable =
+ (VkStridedDeviceAddressRegionKHR*)stack_pHitShaderBindingTable;
+ reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable), readStreamPtrPtr);
+ pCallableShaderBindingTable =
+ (VkStridedDeviceAddressRegionKHR*)stack_pCallableShaderBindingTable;
+ reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable),
+ readStreamPtrPtr);
+ memcpy((VkDeviceAddress*)&indirectDeviceAddress, *readStreamPtrPtr,
+ sizeof(VkDeviceAddress));
+ *readStreamPtrPtr += sizeof(VkDeviceAddress);
+ if (pRaygenShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ globalstate, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable));
+ }
+ if (pMissShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ globalstate, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable));
+ }
+ if (pHitShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ globalstate, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable));
+ }
+ if (pCallableShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ globalstate,
+ (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable));
+ }
+ vk->vkCmdTraceRaysIndirectKHR((VkCommandBuffer)dispatchHandle,
+ pRaygenShaderBindingTable, pMissShaderBindingTable,
+ pHitShaderBindingTable, pCallableShaderBindingTable,
+ indirectDeviceAddress);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdSetRayTracingPipelineStackSizeKHR: {
+ android::base::beginTrace("vkCmdSetRayTracingPipelineStackSizeKHR subdecode");
+ uint32_t pipelineStackSize;
+ memcpy((uint32_t*)&pipelineStackSize, *readStreamPtrPtr, sizeof(uint32_t));
+ *readStreamPtrPtr += sizeof(uint32_t);
+ vk->vkCmdSetRayTracingPipelineStackSizeKHR((VkCommandBuffer)dispatchHandle,
+ pipelineStackSize);
+ android::base::endTrace();
+ break;
+ }
+#endif
default: {
GFXSTREAM_ABORT(::emugl::FatalError(::emugl::ABORT_REASON_OTHER))
<< "Unrecognized opcode " << opcode;
diff --git a/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp b/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
index f5e33a2..6cf3ab5 100644
--- a/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
@@ -7121,6 +7121,35 @@
}
#endif
+#ifdef VK_KHR_pipeline_library
+void deepcopy_VkPipelineLibraryCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineLibraryCreateInfoKHR* from,
+ VkPipelineLibraryCreateInfoKHR* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pLibraries = nullptr;
+ if (from->pLibraries) {
+ to->pLibraries = (VkPipeline*)alloc->dupArray(
+ from->pLibraries, from->libraryCount * sizeof(const VkPipeline));
+ }
+}
+
+#endif
#ifdef VK_KHR_synchronization2
void deepcopy_VkQueueFamilyCheckpointProperties2NV(Allocator* alloc, VkStructureType rootType,
const VkQueueFamilyCheckpointProperties2NV* from,
@@ -9222,6 +9251,192 @@
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+void deepcopy_VkRayTracingShaderGroupCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoKHR* from,
+ VkRayTracingShaderGroupCreateInfoKHR* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pShaderGroupCaptureReplayHandle = nullptr;
+ if (from->pShaderGroupCaptureReplayHandle) {
+ to->pShaderGroupCaptureReplayHandle =
+ (void*)alloc->dupArray(from->pShaderGroupCaptureReplayHandle, sizeof(const uint8_t));
+ }
+}
+
+void deepcopy_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ Allocator* alloc, VkStructureType rootType,
+ const VkRayTracingPipelineInterfaceCreateInfoKHR* from,
+ VkRayTracingPipelineInterfaceCreateInfoKHR* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkRayTracingPipelineCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoKHR* from,
+ VkRayTracingPipelineCreateInfoKHR* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ if (from) {
+ to->pStages = nullptr;
+ if (from->pStages) {
+ to->pStages = (VkPipelineShaderStageCreateInfo*)alloc->alloc(
+ from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
+ to->stageCount = from->stageCount;
+ for (uint32_t i = 0; i < (uint32_t)from->stageCount; ++i) {
+ deepcopy_VkPipelineShaderStageCreateInfo(
+ alloc, rootType, from->pStages + i,
+ (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
+ }
+ }
+ }
+ if (from) {
+ to->pGroups = nullptr;
+ if (from->pGroups) {
+ to->pGroups = (VkRayTracingShaderGroupCreateInfoKHR*)alloc->alloc(
+ from->groupCount * sizeof(const VkRayTracingShaderGroupCreateInfoKHR));
+ to->groupCount = from->groupCount;
+ for (uint32_t i = 0; i < (uint32_t)from->groupCount; ++i) {
+ deepcopy_VkRayTracingShaderGroupCreateInfoKHR(
+ alloc, rootType, from->pGroups + i,
+ (VkRayTracingShaderGroupCreateInfoKHR*)(to->pGroups + i));
+ }
+ }
+ }
+ to->pLibraryInfo = nullptr;
+ if (from->pLibraryInfo) {
+ to->pLibraryInfo = (VkPipelineLibraryCreateInfoKHR*)alloc->alloc(
+ sizeof(const VkPipelineLibraryCreateInfoKHR));
+ deepcopy_VkPipelineLibraryCreateInfoKHR(
+ alloc, rootType, from->pLibraryInfo,
+ (VkPipelineLibraryCreateInfoKHR*)(to->pLibraryInfo));
+ }
+ to->pLibraryInterface = nullptr;
+ if (from->pLibraryInterface) {
+ to->pLibraryInterface = (VkRayTracingPipelineInterfaceCreateInfoKHR*)alloc->alloc(
+ sizeof(const VkRayTracingPipelineInterfaceCreateInfoKHR));
+ deepcopy_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ alloc, rootType, from->pLibraryInterface,
+ (VkRayTracingPipelineInterfaceCreateInfoKHR*)(to->pLibraryInterface));
+ }
+ to->pDynamicState = nullptr;
+ if (from->pDynamicState) {
+ to->pDynamicState = (VkPipelineDynamicStateCreateInfo*)alloc->alloc(
+ sizeof(const VkPipelineDynamicStateCreateInfo));
+ deepcopy_VkPipelineDynamicStateCreateInfo(
+ alloc, rootType, from->pDynamicState,
+ (VkPipelineDynamicStateCreateInfo*)(to->pDynamicState));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* from,
+ VkPhysicalDeviceRayTracingPipelineFeaturesKHR* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* from,
+ VkPhysicalDeviceRayTracingPipelinePropertiesKHR* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkStridedDeviceAddressRegionKHR(Allocator* alloc, VkStructureType rootType,
+ const VkStridedDeviceAddressRegionKHR* from,
+ VkStridedDeviceAddressRegionKHR* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+}
+
+void deepcopy_VkTraceRaysIndirectCommandKHR(Allocator* alloc, VkStructureType rootType,
+ const VkTraceRaysIndirectCommandKHR* from,
+ VkTraceRaysIndirectCommandKHR* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+}
+
+#endif
void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
const void* structExtension, void* structExtension_out) {
if (!structExtension) {
@@ -10125,6 +10340,15 @@
break;
}
#endif
+#ifdef VK_KHR_pipeline_library
+ case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
+ deepcopy_VkPipelineLibraryCreateInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineLibraryCreateInfoKHR*>(structExtension),
+ reinterpret_cast<VkPipelineLibraryCreateInfoKHR*>(structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_KHR_synchronization2
case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
deepcopy_VkQueueFamilyCheckpointProperties2NV(
@@ -10756,6 +10980,26 @@
break;
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
+ deepcopy_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
+ deepcopy_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
+ structExtension_out));
+ break;
+ }
+#endif
default: {
return;
}
diff --git a/host/vulkan/cereal/common/goldfish_vk_deepcopy.h b/host/vulkan/cereal/common/goldfish_vk_deepcopy.h
index 3c9fd6a..2312fec 100644
--- a/host/vulkan/cereal/common/goldfish_vk_deepcopy.h
+++ b/host/vulkan/cereal/common/goldfish_vk_deepcopy.h
@@ -1507,6 +1507,12 @@
deepcopy_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR)
#endif
+#ifdef VK_KHR_pipeline_library
+void deepcopy_VkPipelineLibraryCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineLibraryCreateInfoKHR* from,
+ VkPipelineLibraryCreateInfoKHR* to);
+
+#endif
#ifdef VK_KHR_synchronization2
DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryBarrier2, deepcopy_VkMemoryBarrier2KHR)
@@ -2070,5 +2076,38 @@
VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* to);
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+void deepcopy_VkRayTracingShaderGroupCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoKHR* from,
+ VkRayTracingShaderGroupCreateInfoKHR* to);
+
+void deepcopy_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ Allocator* alloc, VkStructureType rootType,
+ const VkRayTracingPipelineInterfaceCreateInfoKHR* from,
+ VkRayTracingPipelineInterfaceCreateInfoKHR* to);
+
+void deepcopy_VkRayTracingPipelineCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoKHR* from,
+ VkRayTracingPipelineCreateInfoKHR* to);
+
+void deepcopy_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* from,
+ VkPhysicalDeviceRayTracingPipelineFeaturesKHR* to);
+
+void deepcopy_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* from,
+ VkPhysicalDeviceRayTracingPipelinePropertiesKHR* to);
+
+void deepcopy_VkStridedDeviceAddressRegionKHR(Allocator* alloc, VkStructureType rootType,
+ const VkStridedDeviceAddressRegionKHR* from,
+ VkStridedDeviceAddressRegionKHR* to);
+
+void deepcopy_VkTraceRaysIndirectCommandKHR(Allocator* alloc, VkStructureType rootType,
+ const VkTraceRaysIndirectCommandKHR* from,
+ VkTraceRaysIndirectCommandKHR* to);
+
+#endif
} // namespace vk
} // namespace gfxstream
diff --git a/host/vulkan/cereal/common/goldfish_vk_dispatch.cpp b/host/vulkan/cereal/common/goldfish_vk_dispatch.cpp
index a384265..4b8d4a3 100644
--- a/host/vulkan/cereal/common/goldfish_vk_dispatch.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_dispatch.cpp
@@ -795,6 +795,22 @@
out->vkGetScreenBufferPropertiesQNX =
(PFN_vkGetScreenBufferPropertiesQNX)dlSymFunc(lib, "vkGetScreenBufferPropertiesQNX");
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ out->vkCmdTraceRaysKHR = (PFN_vkCmdTraceRaysKHR)dlSymFunc(lib, "vkCmdTraceRaysKHR");
+ out->vkCreateRayTracingPipelinesKHR =
+ (PFN_vkCreateRayTracingPipelinesKHR)dlSymFunc(lib, "vkCreateRayTracingPipelinesKHR");
+ out->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR =
+ (PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)dlSymFunc(
+ lib, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR");
+ out->vkCmdTraceRaysIndirectKHR =
+ (PFN_vkCmdTraceRaysIndirectKHR)dlSymFunc(lib, "vkCmdTraceRaysIndirectKHR");
+ out->vkGetRayTracingShaderGroupStackSizeKHR =
+ (PFN_vkGetRayTracingShaderGroupStackSizeKHR)dlSymFunc(
+ lib, "vkGetRayTracingShaderGroupStackSizeKHR");
+ out->vkCmdSetRayTracingPipelineStackSizeKHR =
+ (PFN_vkCmdSetRayTracingPipelineStackSizeKHR)dlSymFunc(
+ lib, "vkCmdSetRayTracingPipelineStackSizeKHR");
+#endif
}
void init_vulkan_dispatch_from_instance(VulkanDispatch* vk, VkInstance instance,
@@ -1766,6 +1782,24 @@
(PFN_vkGetScreenBufferPropertiesQNX)vk->vkGetInstanceProcAddr(
instance, "vkGetScreenBufferPropertiesQNX");
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ out->vkCmdTraceRaysKHR =
+ (PFN_vkCmdTraceRaysKHR)vk->vkGetInstanceProcAddr(instance, "vkCmdTraceRaysKHR");
+ out->vkCreateRayTracingPipelinesKHR =
+ (PFN_vkCreateRayTracingPipelinesKHR)vk->vkGetInstanceProcAddr(
+ instance, "vkCreateRayTracingPipelinesKHR");
+ out->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR =
+ (PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)vk->vkGetInstanceProcAddr(
+ instance, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR");
+ out->vkCmdTraceRaysIndirectKHR = (PFN_vkCmdTraceRaysIndirectKHR)vk->vkGetInstanceProcAddr(
+ instance, "vkCmdTraceRaysIndirectKHR");
+ out->vkGetRayTracingShaderGroupStackSizeKHR =
+ (PFN_vkGetRayTracingShaderGroupStackSizeKHR)vk->vkGetInstanceProcAddr(
+ instance, "vkGetRayTracingShaderGroupStackSizeKHR");
+ out->vkCmdSetRayTracingPipelineStackSizeKHR =
+ (PFN_vkCmdSetRayTracingPipelineStackSizeKHR)vk->vkGetInstanceProcAddr(
+ instance, "vkCmdSetRayTracingPipelineStackSizeKHR");
+#endif
}
void init_vulkan_dispatch_from_device(VulkanDispatch* vk, VkDevice device, VulkanDispatch* out) {
@@ -2710,6 +2744,24 @@
(PFN_vkGetScreenBufferPropertiesQNX)vk->vkGetDeviceProcAddr(
device, "vkGetScreenBufferPropertiesQNX");
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ out->vkCmdTraceRaysKHR =
+ (PFN_vkCmdTraceRaysKHR)vk->vkGetDeviceProcAddr(device, "vkCmdTraceRaysKHR");
+ out->vkCreateRayTracingPipelinesKHR =
+ (PFN_vkCreateRayTracingPipelinesKHR)vk->vkGetDeviceProcAddr(
+ device, "vkCreateRayTracingPipelinesKHR");
+ out->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR =
+ (PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)vk->vkGetDeviceProcAddr(
+ device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR");
+ out->vkCmdTraceRaysIndirectKHR =
+ (PFN_vkCmdTraceRaysIndirectKHR)vk->vkGetDeviceProcAddr(device, "vkCmdTraceRaysIndirectKHR");
+ out->vkGetRayTracingShaderGroupStackSizeKHR =
+ (PFN_vkGetRayTracingShaderGroupStackSizeKHR)vk->vkGetDeviceProcAddr(
+ device, "vkGetRayTracingShaderGroupStackSizeKHR");
+ out->vkCmdSetRayTracingPipelineStackSizeKHR =
+ (PFN_vkCmdSetRayTracingPipelineStackSizeKHR)vk->vkGetDeviceProcAddr(
+ device, "vkCmdSetRayTracingPipelineStackSizeKHR");
+#endif
}
bool vulkan_dispatch_check_instance_VK_VERSION_1_0(const VulkanDispatch* vk)
diff --git a/host/vulkan/cereal/common/goldfish_vk_dispatch.h b/host/vulkan/cereal/common/goldfish_vk_dispatch.h
index 70be902..3723f23 100644
--- a/host/vulkan/cereal/common/goldfish_vk_dispatch.h
+++ b/host/vulkan/cereal/common/goldfish_vk_dispatch.h
@@ -552,6 +552,15 @@
#ifdef VK_QNX_external_memory_screen_buffer
PFN_vkGetScreenBufferPropertiesQNX vkGetScreenBufferPropertiesQNX;
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR;
+ PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR;
+ PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR
+ vkGetRayTracingCaptureReplayShaderGroupHandlesKHR;
+ PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR;
+ PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR;
+ PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR;
+#endif
};
} // namespace vk
diff --git a/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp b/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp
index 0811108..0cfedea 100644
--- a/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp
@@ -14643,6 +14643,58 @@
}
#endif
+#ifdef VK_KHR_pipeline_library
+void marshal_VkPipelineLibraryCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+ const VkPipelineLibraryCreateInfoKHR* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((uint32_t*)&forMarshaling->libraryCount, sizeof(uint32_t));
+ if (forMarshaling->libraryCount) {
+ uint64_t* cgen_var_0;
+ vkStream->alloc((void**)&cgen_var_0, forMarshaling->libraryCount * 8);
+ vkStream->handleMapping()->mapHandles_VkPipeline_u64(forMarshaling->pLibraries, cgen_var_0,
+ forMarshaling->libraryCount);
+ vkStream->write((uint64_t*)cgen_var_0, forMarshaling->libraryCount * 8);
+ }
+}
+
+void unmarshal_VkPipelineLibraryCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+ VkPipelineLibraryCreateInfoKHR* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->libraryCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pLibraries,
+ forUnmarshaling->libraryCount * sizeof(const VkPipeline));
+ if (forUnmarshaling->libraryCount) {
+ uint64_t* cgen_var_0;
+ vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->libraryCount * 8);
+ vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->libraryCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(
+ cgen_var_0, (VkPipeline*)forUnmarshaling->pLibraries, forUnmarshaling->libraryCount);
+ }
+}
+
+#endif
#ifdef VK_KHR_synchronization2
void marshal_VkQueueFamilyCheckpointProperties2NV(
VulkanStream* vkStream, VkStructureType rootType,
@@ -18266,6 +18318,389 @@
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+void marshal_VkRayTracingShaderGroupCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoKHR* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkRayTracingShaderGroupTypeKHR*)&forMarshaling->type,
+ sizeof(VkRayTracingShaderGroupTypeKHR));
+ vkStream->write((uint32_t*)&forMarshaling->generalShader, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->closestHitShader, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->anyHitShader, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->intersectionShader, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pShaderGroupCaptureReplayHandle;
+ vkStream->putBe64(cgen_var_0);
+ if (forMarshaling->pShaderGroupCaptureReplayHandle) {
+ vkStream->write((const void*)forMarshaling->pShaderGroupCaptureReplayHandle,
+ sizeof(const uint8_t));
+ }
+}
+
+void unmarshal_VkRayTracingShaderGroupCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkRayTracingShaderGroupCreateInfoKHR* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkRayTracingShaderGroupTypeKHR*)&forUnmarshaling->type,
+ sizeof(VkRayTracingShaderGroupTypeKHR));
+ vkStream->read((uint32_t*)&forUnmarshaling->generalShader, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->closestHitShader, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->anyHitShader, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->intersectionShader, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pShaderGroupCaptureReplayHandle = (const void*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pShaderGroupCaptureReplayHandle) {
+ vkStream->alloc((void**)&forUnmarshaling->pShaderGroupCaptureReplayHandle,
+ sizeof(const uint8_t));
+ vkStream->read((void*)forUnmarshaling->pShaderGroupCaptureReplayHandle,
+ sizeof(const uint8_t));
+ }
+}
+
+void marshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkRayTracingPipelineInterfaceCreateInfoKHR* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((uint32_t*)&forMarshaling->maxPipelineRayPayloadSize, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPipelineRayHitAttributeSize, sizeof(uint32_t));
+}
+
+void unmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkRayTracingPipelineInterfaceCreateInfoKHR* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPipelineRayPayloadSize, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPipelineRayHitAttributeSize, sizeof(uint32_t));
+}
+
+void marshal_VkRayTracingPipelineCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoKHR* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
+ vkStream->write((uint32_t*)&forMarshaling->stageCount, sizeof(uint32_t));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i) {
+ marshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
+ }
+ }
+ vkStream->write((uint32_t*)&forMarshaling->groupCount, sizeof(uint32_t));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i) {
+ marshal_VkRayTracingShaderGroupCreateInfoKHR(
+ vkStream, rootType,
+ (const VkRayTracingShaderGroupCreateInfoKHR*)(forMarshaling->pGroups + i));
+ }
+ }
+ vkStream->write((uint32_t*)&forMarshaling->maxPipelineRayRecursionDepth, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pLibraryInfo;
+ vkStream->putBe64(cgen_var_0);
+ if (forMarshaling->pLibraryInfo) {
+ marshal_VkPipelineLibraryCreateInfoKHR(
+ vkStream, rootType,
+ (const VkPipelineLibraryCreateInfoKHR*)(forMarshaling->pLibraryInfo));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pLibraryInterface;
+ vkStream->putBe64(cgen_var_1);
+ if (forMarshaling->pLibraryInterface) {
+ marshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ vkStream, rootType,
+ (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(forMarshaling->pLibraryInterface));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pDynamicState;
+ vkStream->putBe64(cgen_var_2);
+ if (forMarshaling->pDynamicState) {
+ marshal_VkPipelineDynamicStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState));
+ }
+ uint64_t cgen_var_3;
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_3,
+ 1);
+ vkStream->write((uint64_t*)&cgen_var_3, 1 * 8);
+ uint64_t cgen_var_4;
+ vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle,
+ &cgen_var_4, 1);
+ vkStream->write((uint64_t*)&cgen_var_4, 1 * 8);
+ vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
+}
+
+void unmarshal_VkRayTracingPipelineCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkRayTracingPipelineCreateInfoKHR* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->stageCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pStages,
+ forUnmarshaling->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i) {
+ unmarshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType,
+ (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
+ }
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->groupCount, sizeof(uint32_t));
+ vkStream->alloc(
+ (void**)&forUnmarshaling->pGroups,
+ forUnmarshaling->groupCount * sizeof(const VkRayTracingShaderGroupCreateInfoKHR));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->groupCount; ++i) {
+ unmarshal_VkRayTracingShaderGroupCreateInfoKHR(
+ vkStream, rootType,
+ (VkRayTracingShaderGroupCreateInfoKHR*)(forUnmarshaling->pGroups + i));
+ }
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPipelineRayRecursionDepth, sizeof(uint32_t));
+ // WARNING PTR CHECK
+ forUnmarshaling->pLibraryInfo =
+ (const VkPipelineLibraryCreateInfoKHR*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pLibraryInfo) {
+ vkStream->alloc((void**)&forUnmarshaling->pLibraryInfo,
+ sizeof(const VkPipelineLibraryCreateInfoKHR));
+ unmarshal_VkPipelineLibraryCreateInfoKHR(
+ vkStream, rootType, (VkPipelineLibraryCreateInfoKHR*)(forUnmarshaling->pLibraryInfo));
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->pLibraryInterface =
+ (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pLibraryInterface) {
+ vkStream->alloc((void**)&forUnmarshaling->pLibraryInterface,
+ sizeof(const VkRayTracingPipelineInterfaceCreateInfoKHR));
+ unmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ vkStream, rootType,
+ (VkRayTracingPipelineInterfaceCreateInfoKHR*)(forUnmarshaling->pLibraryInterface));
+ }
+ // WARNING PTR CHECK
+ forUnmarshaling->pDynamicState =
+ (const VkPipelineDynamicStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pDynamicState) {
+ vkStream->alloc((void**)&forUnmarshaling->pDynamicState,
+ sizeof(const VkPipelineDynamicStateCreateInfo));
+ unmarshal_VkPipelineDynamicStateCreateInfo(
+ vkStream, rootType,
+ (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState));
+ }
+ uint64_t cgen_var_3;
+ vkStream->read((uint64_t*)&cgen_var_3, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
+ &cgen_var_3, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+ uint64_t cgen_var_4;
+ vkStream->read((uint64_t*)&cgen_var_4, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(
+ &cgen_var_4, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
+ vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
+}
+
+void marshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkBool32*)&forMarshaling->rayTracingPipeline, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->rayTracingPipelineShaderGroupHandleCaptureReplay,
+ sizeof(VkBool32));
+ vkStream->write(
+ (VkBool32*)&forMarshaling->rayTracingPipelineShaderGroupHandleCaptureReplayMixed,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->rayTracingPipelineTraceRaysIndirect,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->rayTraversalPrimitiveCulling, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkBool32*)&forUnmarshaling->rayTracingPipeline, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->rayTracingPipelineShaderGroupHandleCaptureReplay,
+ sizeof(VkBool32));
+ vkStream->read(
+ (VkBool32*)&forUnmarshaling->rayTracingPipelineShaderGroupHandleCaptureReplayMixed,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->rayTracingPipelineTraceRaysIndirect,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->rayTraversalPrimitiveCulling, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((uint32_t*)&forMarshaling->shaderGroupHandleSize, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxRayRecursionDepth, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxShaderGroupStride, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->shaderGroupBaseAlignment, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->shaderGroupHandleCaptureReplaySize,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxRayDispatchInvocationCount, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->shaderGroupHandleAlignment, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxRayHitAttributeSize, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->shaderGroupHandleSize, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxRayRecursionDepth, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxShaderGroupStride, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->shaderGroupBaseAlignment, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->shaderGroupHandleCaptureReplaySize,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxRayDispatchInvocationCount, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->shaderGroupHandleAlignment, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxRayHitAttributeSize, sizeof(uint32_t));
+}
+
+void marshal_VkStridedDeviceAddressRegionKHR(VulkanStream* vkStream, VkStructureType rootType,
+ const VkStridedDeviceAddressRegionKHR* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
+ vkStream->write((VkDeviceSize*)&forMarshaling->stride, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkStridedDeviceAddressRegionKHR(VulkanStream* vkStream, VkStructureType rootType,
+ VkStridedDeviceAddressRegionKHR* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->stride, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+}
+
+void marshal_VkTraceRaysIndirectCommandKHR(VulkanStream* vkStream, VkStructureType rootType,
+ const VkTraceRaysIndirectCommandKHR* forMarshaling) {
+ (void)rootType;
+ vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->depth, sizeof(uint32_t));
+}
+
+void unmarshal_VkTraceRaysIndirectCommandKHR(VulkanStream* vkStream, VkStructureType rootType,
+ VkTraceRaysIndirectCommandKHR* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->depth, sizeof(uint32_t));
+}
+
+#endif
void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
const void* structExtension) {
VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension);
@@ -19045,6 +19480,14 @@
break;
}
#endif
+#ifdef VK_KHR_pipeline_library
+ case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
+ marshal_VkPipelineLibraryCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineLibraryCreateInfoKHR*>(structExtension));
+ break;
+ }
+#endif
#ifdef VK_KHR_synchronization2
case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
marshal_VkQueueFamilyCheckpointProperties2NV(
@@ -19576,6 +20019,22 @@
break;
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
+ marshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
+ structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
+ marshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
+ structExtension));
+ break;
+ }
+#endif
default: {
// fatal; the switch is only taken if the extension struct is known
abort();
@@ -20351,6 +20810,14 @@
break;
}
#endif
+#ifdef VK_KHR_pipeline_library
+ case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
+ unmarshal_VkPipelineLibraryCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineLibraryCreateInfoKHR*>(structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_KHR_synchronization2
case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
unmarshal_VkQueueFamilyCheckpointProperties2NV(
@@ -20875,6 +21342,22 @@
break;
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
+ unmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
+ unmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
+ structExtension_out));
+ break;
+ }
+#endif
default: {
// fatal; the switch is only taken if the extension struct is known
abort();
@@ -21676,6 +22159,11 @@
return "OP_vkCopyImageToMemoryEXT";
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ case OP_vkGetRayTracingShaderGroupStackSizeKHR: {
+ return "OP_vkGetRayTracingShaderGroupStackSizeKHR";
+ }
+#endif
#ifdef VK_EXT_extended_dynamic_state2
case OP_vkCmdSetPatchControlPointsEXT: {
return "OP_vkCmdSetPatchControlPointsEXT";
@@ -21691,6 +22179,11 @@
return "OP_vkCmdSetDepthTestEnable";
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ case OP_vkCmdTraceRaysIndirectKHR: {
+ return "OP_vkCmdTraceRaysIndirectKHR";
+ }
+#endif
#ifdef VK_EXT_extended_dynamic_state
case OP_vkCmdSetFrontFaceEXT: {
return "OP_vkCmdSetFrontFaceEXT";
@@ -21701,6 +22194,11 @@
return "OP_vkCollectDescriptorPoolIdsGOOGLE";
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ case OP_vkCmdTraceRaysKHR: {
+ return "OP_vkCmdTraceRaysKHR";
+ }
+#endif
#ifdef VK_VERSION_1_3
case OP_vkCmdCopyImageToBuffer2: {
return "OP_vkCmdCopyImageToBuffer2";
@@ -21736,6 +22234,13 @@
case OP_vkCmdEndRenderPass2: {
return "OP_vkCmdEndRenderPass2";
}
+#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ case OP_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR: {
+ return "OP_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR";
+ }
+#endif
+#ifdef VK_VERSION_1_2
case OP_vkGetBufferDeviceAddress: {
return "OP_vkGetBufferDeviceAddress";
}
@@ -21913,6 +22418,11 @@
return "OP_vkCmdCopyImage2";
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ case OP_vkCreateRayTracingPipelinesKHR: {
+ return "OP_vkCreateRayTracingPipelinesKHR";
+ }
+#endif
#ifdef VK_EXT_extended_dynamic_state
case OP_vkCmdSetDepthCompareOpEXT: {
return "OP_vkCmdSetDepthCompareOpEXT";
@@ -21971,6 +22481,11 @@
return "OP_vkCmdBlitImage2KHR";
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ case OP_vkCmdSetRayTracingPipelineStackSizeKHR: {
+ return "OP_vkCmdSetRayTracingPipelineStackSizeKHR";
+ }
+#endif
#ifdef VK_VERSION_1_2
case OP_vkGetDeviceMemoryOpaqueCaptureAddress: {
return "OP_vkGetDeviceMemoryOpaqueCaptureAddress";
diff --git a/host/vulkan/cereal/common/goldfish_vk_marshaling.h b/host/vulkan/cereal/common/goldfish_vk_marshaling.h
index 67b9635..ada18ae 100644
--- a/host/vulkan/cereal/common/goldfish_vk_marshaling.h
+++ b/host/vulkan/cereal/common/goldfish_vk_marshaling.h
@@ -2863,6 +2863,14 @@
unmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR)
#endif
+#ifdef VK_KHR_pipeline_library
+void marshal_VkPipelineLibraryCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+ const VkPipelineLibraryCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkPipelineLibraryCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+ VkPipelineLibraryCreateInfoKHR* forUnmarshaling);
+
+#endif
#ifdef VK_KHR_synchronization2
DEFINE_ALIAS_FUNCTION(marshal_VkMemoryBarrier2, marshal_VkMemoryBarrier2KHR)
@@ -3885,6 +3893,66 @@
VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* forUnmarshaling);
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+void marshal_VkRayTracingShaderGroupCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkRayTracingShaderGroupCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkRayTracingShaderGroupCreateInfoKHR* forUnmarshaling);
+
+void marshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkRayTracingPipelineInterfaceCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkRayTracingPipelineInterfaceCreateInfoKHR* forUnmarshaling);
+
+void marshal_VkRayTracingPipelineCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkRayTracingPipelineCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkRayTracingPipelineCreateInfoKHR* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forUnmarshaling);
+
+void marshal_VkStridedDeviceAddressRegionKHR(VulkanStream* vkStream, VkStructureType rootType,
+ const VkStridedDeviceAddressRegionKHR* forMarshaling);
+
+void unmarshal_VkStridedDeviceAddressRegionKHR(VulkanStream* vkStream, VkStructureType rootType,
+ VkStridedDeviceAddressRegionKHR* forUnmarshaling);
+
+void marshal_VkTraceRaysIndirectCommandKHR(VulkanStream* vkStream, VkStructureType rootType,
+ const VkTraceRaysIndirectCommandKHR* forMarshaling);
+
+void unmarshal_VkTraceRaysIndirectCommandKHR(VulkanStream* vkStream, VkStructureType rootType,
+ VkTraceRaysIndirectCommandKHR* forUnmarshaling);
+
+#define OP_vkCmdTraceRaysKHR 213680716
+#define OP_vkCreateRayTracingPipelinesKHR 247628685
+#define OP_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR 221334934
+#define OP_vkCmdTraceRaysIndirectKHR 211788517
+#define OP_vkGetRayTracingShaderGroupStackSizeKHR 205271933
+#define OP_vkCmdSetRayTracingPipelineStackSizeKHR 260219604
+#endif
const char* api_opcode_to_string(const uint32_t opcode);
#define OP_vkFirst_old 20000
diff --git a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
index 5bb230e..1e8136f 100644
--- a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
@@ -11259,6 +11259,51 @@
}
#endif
+#ifdef VK_KHR_pipeline_library
+void reservedunmarshal_VkPipelineLibraryCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPipelineLibraryCreateInfoKHR* forUnmarshaling, uint8_t** ptr) {
+ memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ uint32_t pNext_size;
+ memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+ android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+ *ptr += sizeof(uint32_t);
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+ ptr);
+ }
+ memcpy((uint32_t*)&forUnmarshaling->libraryCount, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ vkStream->alloc((void**)&forUnmarshaling->pLibraries,
+ forUnmarshaling->libraryCount * sizeof(const VkPipeline));
+ if (forUnmarshaling->libraryCount) {
+ uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
+ *ptr += 8 * forUnmarshaling->libraryCount;
+ if (forUnmarshaling) {
+ for (uint32_t k = 0; k < forUnmarshaling->libraryCount; ++k) {
+ uint64_t tmpval;
+ memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
+ *(((VkPipeline*)forUnmarshaling->pLibraries) + k) =
+ (VkPipeline)unbox_VkPipeline((VkPipeline)tmpval);
+ }
+ }
+ }
+}
+
+#endif
#ifdef VK_KHR_synchronization2
void reservedunmarshal_VkQueueFamilyCheckpointProperties2NV(
VulkanStream* vkStream, VkStructureType rootType,
@@ -14142,6 +14187,290 @@
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+void reservedunmarshal_VkRayTracingShaderGroupCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkRayTracingShaderGroupCreateInfoKHR* forUnmarshaling, uint8_t** ptr) {
+ memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ uint32_t pNext_size;
+ memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+ android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+ *ptr += sizeof(uint32_t);
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+ ptr);
+ }
+ memcpy((VkRayTracingShaderGroupTypeKHR*)&forUnmarshaling->type, *ptr,
+ sizeof(VkRayTracingShaderGroupTypeKHR));
+ *ptr += sizeof(VkRayTracingShaderGroupTypeKHR);
+ memcpy((uint32_t*)&forUnmarshaling->generalShader, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy((uint32_t*)&forUnmarshaling->closestHitShader, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy((uint32_t*)&forUnmarshaling->anyHitShader, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy((uint32_t*)&forUnmarshaling->intersectionShader, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ memcpy((void**)&forUnmarshaling->pShaderGroupCaptureReplayHandle, (*ptr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pShaderGroupCaptureReplayHandle);
+ *ptr += 8;
+ if (forUnmarshaling->pShaderGroupCaptureReplayHandle) {
+ vkStream->alloc((void**)&forUnmarshaling->pShaderGroupCaptureReplayHandle,
+ sizeof(const uint8_t));
+ memcpy((void*)forUnmarshaling->pShaderGroupCaptureReplayHandle, *ptr,
+ sizeof(const uint8_t));
+ *ptr += sizeof(const uint8_t);
+ }
+}
+
+void reservedunmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkRayTracingPipelineInterfaceCreateInfoKHR* forUnmarshaling, uint8_t** ptr) {
+ memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ uint32_t pNext_size;
+ memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+ android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+ *ptr += sizeof(uint32_t);
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+ ptr);
+ }
+ memcpy((uint32_t*)&forUnmarshaling->maxPipelineRayPayloadSize, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy((uint32_t*)&forUnmarshaling->maxPipelineRayHitAttributeSize, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkRayTracingPipelineCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkRayTracingPipelineCreateInfoKHR* forUnmarshaling, uint8_t** ptr) {
+ memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ uint32_t pNext_size;
+ memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+ android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+ *ptr += sizeof(uint32_t);
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+ ptr);
+ }
+ memcpy((VkPipelineCreateFlags*)&forUnmarshaling->flags, *ptr, sizeof(VkPipelineCreateFlags));
+ *ptr += sizeof(VkPipelineCreateFlags);
+ memcpy((uint32_t*)&forUnmarshaling->stageCount, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ vkStream->alloc((void**)&forUnmarshaling->pStages,
+ forUnmarshaling->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i) {
+ reservedunmarshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i),
+ ptr);
+ }
+ memcpy((uint32_t*)&forUnmarshaling->groupCount, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ vkStream->alloc(
+ (void**)&forUnmarshaling->pGroups,
+ forUnmarshaling->groupCount * sizeof(const VkRayTracingShaderGroupCreateInfoKHR));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->groupCount; ++i) {
+ reservedunmarshal_VkRayTracingShaderGroupCreateInfoKHR(
+ vkStream, rootType,
+ (VkRayTracingShaderGroupCreateInfoKHR*)(forUnmarshaling->pGroups + i), ptr);
+ }
+ memcpy((uint32_t*)&forUnmarshaling->maxPipelineRayRecursionDepth, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ // WARNING PTR CHECK
+ memcpy((VkPipelineLibraryCreateInfoKHR**)&forUnmarshaling->pLibraryInfo, (*ptr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pLibraryInfo);
+ *ptr += 8;
+ if (forUnmarshaling->pLibraryInfo) {
+ vkStream->alloc((void**)&forUnmarshaling->pLibraryInfo,
+ sizeof(const VkPipelineLibraryCreateInfoKHR));
+ reservedunmarshal_VkPipelineLibraryCreateInfoKHR(
+ vkStream, rootType, (VkPipelineLibraryCreateInfoKHR*)(forUnmarshaling->pLibraryInfo),
+ ptr);
+ }
+ // WARNING PTR CHECK
+ memcpy((VkRayTracingPipelineInterfaceCreateInfoKHR**)&forUnmarshaling->pLibraryInterface,
+ (*ptr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pLibraryInterface);
+ *ptr += 8;
+ if (forUnmarshaling->pLibraryInterface) {
+ vkStream->alloc((void**)&forUnmarshaling->pLibraryInterface,
+ sizeof(const VkRayTracingPipelineInterfaceCreateInfoKHR));
+ reservedunmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ vkStream, rootType,
+ (VkRayTracingPipelineInterfaceCreateInfoKHR*)(forUnmarshaling->pLibraryInterface), ptr);
+ }
+ // WARNING PTR CHECK
+ memcpy((VkPipelineDynamicStateCreateInfo**)&forUnmarshaling->pDynamicState, (*ptr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pDynamicState);
+ *ptr += 8;
+ if (forUnmarshaling->pDynamicState) {
+ vkStream->alloc((void**)&forUnmarshaling->pDynamicState,
+ sizeof(const VkPipelineDynamicStateCreateInfo));
+ reservedunmarshal_VkPipelineDynamicStateCreateInfo(
+ vkStream, rootType, (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState),
+ ptr);
+ }
+ uint64_t cgen_var_3;
+ memcpy((uint64_t*)&cgen_var_3, *ptr, 1 * 8);
+ *ptr += 1 * 8;
+ *(VkPipelineLayout*)&forUnmarshaling->layout =
+ (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_3));
+ uint64_t cgen_var_4;
+ memcpy((uint64_t*)&cgen_var_4, *ptr, 1 * 8);
+ *ptr += 1 * 8;
+ *(VkPipeline*)&forUnmarshaling->basePipelineHandle =
+ (VkPipeline)unbox_VkPipeline((VkPipeline)(*&cgen_var_4));
+ memcpy((int32_t*)&forUnmarshaling->basePipelineIndex, *ptr, sizeof(int32_t));
+ *ptr += sizeof(int32_t);
+}
+
+void reservedunmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forUnmarshaling, uint8_t** ptr) {
+ memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ uint32_t pNext_size;
+ memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+ android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+ *ptr += sizeof(uint32_t);
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+ ptr);
+ }
+ memcpy((VkBool32*)&forUnmarshaling->rayTracingPipeline, *ptr, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy((VkBool32*)&forUnmarshaling->rayTracingPipelineShaderGroupHandleCaptureReplay, *ptr,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy((VkBool32*)&forUnmarshaling->rayTracingPipelineShaderGroupHandleCaptureReplayMixed, *ptr,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy((VkBool32*)&forUnmarshaling->rayTracingPipelineTraceRaysIndirect, *ptr,
+ sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+ memcpy((VkBool32*)&forUnmarshaling->rayTraversalPrimitiveCulling, *ptr, sizeof(VkBool32));
+ *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forUnmarshaling, uint8_t** ptr) {
+ memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ uint32_t pNext_size;
+ memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+ android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+ *ptr += sizeof(uint32_t);
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+ ptr);
+ }
+ memcpy((uint32_t*)&forUnmarshaling->shaderGroupHandleSize, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy((uint32_t*)&forUnmarshaling->maxRayRecursionDepth, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy((uint32_t*)&forUnmarshaling->maxShaderGroupStride, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy((uint32_t*)&forUnmarshaling->shaderGroupBaseAlignment, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy((uint32_t*)&forUnmarshaling->shaderGroupHandleCaptureReplaySize, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy((uint32_t*)&forUnmarshaling->maxRayDispatchInvocationCount, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy((uint32_t*)&forUnmarshaling->shaderGroupHandleAlignment, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy((uint32_t*)&forUnmarshaling->maxRayHitAttributeSize, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkStridedDeviceAddressRegionKHR* forUnmarshaling, uint8_t** ptr) {
+ memcpy((VkDeviceAddress*)&forUnmarshaling->deviceAddress, *ptr, sizeof(VkDeviceAddress));
+ *ptr += sizeof(VkDeviceAddress);
+ memcpy((VkDeviceSize*)&forUnmarshaling->stride, *ptr, sizeof(VkDeviceSize));
+ *ptr += sizeof(VkDeviceSize);
+ memcpy((VkDeviceSize*)&forUnmarshaling->size, *ptr, sizeof(VkDeviceSize));
+ *ptr += sizeof(VkDeviceSize);
+}
+
+void reservedunmarshal_VkTraceRaysIndirectCommandKHR(VulkanStream* vkStream,
+ VkStructureType rootType,
+ VkTraceRaysIndirectCommandKHR* forUnmarshaling,
+ uint8_t** ptr) {
+ memcpy((uint32_t*)&forUnmarshaling->width, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy((uint32_t*)&forUnmarshaling->height, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ memcpy((uint32_t*)&forUnmarshaling->depth, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+}
+
+#endif
void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
void* structExtension_out, uint8_t** ptr) {
VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension_out);
@@ -14965,6 +15294,14 @@
break;
}
#endif
+#ifdef VK_KHR_pipeline_library
+ case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
+ reservedunmarshal_VkPipelineLibraryCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineLibraryCreateInfoKHR*>(structExtension_out), ptr);
+ break;
+ }
+#endif
#ifdef VK_KHR_synchronization2
case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
reservedunmarshal_VkQueueFamilyCheckpointProperties2NV(
@@ -15540,6 +15877,24 @@
break;
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
+ reservedunmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
+ structExtension_out),
+ ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
+ reservedunmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
+ structExtension_out),
+ ptr);
+ break;
+ }
+#endif
default: {
// fatal; the switch is only taken if the extension struct is known
abort();
diff --git a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
index 9411bbf..fcb5de3 100644
--- a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
+++ b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
@@ -1501,6 +1501,12 @@
reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR)
#endif
+#ifdef VK_KHR_pipeline_library
+void reservedunmarshal_VkPipelineLibraryCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPipelineLibraryCreateInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+#endif
#ifdef VK_KHR_synchronization2
DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkMemoryBarrier2, reservedunmarshal_VkMemoryBarrier2KHR)
@@ -2041,5 +2047,36 @@
VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* forUnmarshaling, uint8_t** ptr);
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+void reservedunmarshal_VkRayTracingShaderGroupCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkRayTracingShaderGroupCreateInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkRayTracingPipelineInterfaceCreateInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkRayTracingPipelineCreateInfoKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkRayTracingPipelineCreateInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkStridedDeviceAddressRegionKHR(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkStridedDeviceAddressRegionKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkTraceRaysIndirectCommandKHR(VulkanStream* vkStream,
+ VkStructureType rootType,
+ VkTraceRaysIndirectCommandKHR* forUnmarshaling,
+ uint8_t** ptr);
+
+#endif
} // namespace vk
} // namespace gfxstream
diff --git a/host/vulkan/cereal/common/goldfish_vk_transform.cpp b/host/vulkan/cereal/common/goldfish_vk_transform.cpp
index 5ab0940..5aba5d9 100644
--- a/host/vulkan/cereal/common/goldfish_vk_transform.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_transform.cpp
@@ -6654,6 +6654,26 @@
}
#endif
+#ifdef VK_KHR_pipeline_library
+void transform_tohost_VkPipelineLibraryCreateInfoKHR(VkDecoderGlobalState* resourceTracker,
+ VkPipelineLibraryCreateInfoKHR* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPipelineLibraryCreateInfoKHR(
+ VkDecoderGlobalState* resourceTracker, VkPipelineLibraryCreateInfoKHR* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+#endif
#ifdef VK_KHR_synchronization2
void transform_tohost_VkQueueFamilyCheckpointProperties2NV(
VkDecoderGlobalState* resourceTracker, VkQueueFamilyCheckpointProperties2NV* toTransform) {
@@ -8426,6 +8446,188 @@
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+void transform_tohost_VkRayTracingShaderGroupCreateInfoKHR(
+ VkDecoderGlobalState* resourceTracker, VkRayTracingShaderGroupCreateInfoKHR* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkRayTracingShaderGroupCreateInfoKHR(
+ VkDecoderGlobalState* resourceTracker, VkRayTracingShaderGroupCreateInfoKHR* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ VkDecoderGlobalState* resourceTracker,
+ VkRayTracingPipelineInterfaceCreateInfoKHR* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ VkDecoderGlobalState* resourceTracker,
+ VkRayTracingPipelineInterfaceCreateInfoKHR* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkRayTracingPipelineCreateInfoKHR(
+ VkDecoderGlobalState* resourceTracker, VkRayTracingPipelineCreateInfoKHR* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ if (toTransform) {
+ if (toTransform->pStages) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i) {
+ transform_tohost_VkPipelineShaderStageCreateInfo(
+ resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
+ }
+ }
+ }
+ if (toTransform) {
+ if (toTransform->pGroups) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->groupCount; ++i) {
+ transform_tohost_VkRayTracingShaderGroupCreateInfoKHR(
+ resourceTracker,
+ (VkRayTracingShaderGroupCreateInfoKHR*)(toTransform->pGroups + i));
+ }
+ }
+ }
+ if (toTransform->pLibraryInfo) {
+ transform_tohost_VkPipelineLibraryCreateInfoKHR(
+ resourceTracker, (VkPipelineLibraryCreateInfoKHR*)(toTransform->pLibraryInfo));
+ }
+ if (toTransform->pLibraryInterface) {
+ transform_tohost_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ resourceTracker,
+ (VkRayTracingPipelineInterfaceCreateInfoKHR*)(toTransform->pLibraryInterface));
+ }
+ if (toTransform->pDynamicState) {
+ transform_tohost_VkPipelineDynamicStateCreateInfo(
+ resourceTracker, (VkPipelineDynamicStateCreateInfo*)(toTransform->pDynamicState));
+ }
+}
+
+void transform_fromhost_VkRayTracingPipelineCreateInfoKHR(
+ VkDecoderGlobalState* resourceTracker, VkRayTracingPipelineCreateInfoKHR* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ if (toTransform) {
+ if (toTransform->pStages) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i) {
+ transform_fromhost_VkPipelineShaderStageCreateInfo(
+ resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
+ }
+ }
+ }
+ if (toTransform) {
+ if (toTransform->pGroups) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->groupCount; ++i) {
+ transform_fromhost_VkRayTracingShaderGroupCreateInfoKHR(
+ resourceTracker,
+ (VkRayTracingShaderGroupCreateInfoKHR*)(toTransform->pGroups + i));
+ }
+ }
+ }
+ if (toTransform->pLibraryInfo) {
+ transform_fromhost_VkPipelineLibraryCreateInfoKHR(
+ resourceTracker, (VkPipelineLibraryCreateInfoKHR*)(toTransform->pLibraryInfo));
+ }
+ if (toTransform->pLibraryInterface) {
+ transform_fromhost_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ resourceTracker,
+ (VkRayTracingPipelineInterfaceCreateInfoKHR*)(toTransform->pLibraryInterface));
+ }
+ if (toTransform->pDynamicState) {
+ transform_fromhost_VkPipelineDynamicStateCreateInfo(
+ resourceTracker, (VkPipelineDynamicStateCreateInfo*)(toTransform->pDynamicState));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ VkDecoderGlobalState* resourceTracker,
+ VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ VkDecoderGlobalState* resourceTracker,
+ VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ VkDecoderGlobalState* resourceTracker,
+ VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ VkDecoderGlobalState* resourceTracker,
+ VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkStridedDeviceAddressRegionKHR(
+ VkDecoderGlobalState* resourceTracker, VkStridedDeviceAddressRegionKHR* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+}
+
+void transform_fromhost_VkStridedDeviceAddressRegionKHR(
+ VkDecoderGlobalState* resourceTracker, VkStridedDeviceAddressRegionKHR* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+}
+
+void transform_tohost_VkTraceRaysIndirectCommandKHR(VkDecoderGlobalState* resourceTracker,
+ VkTraceRaysIndirectCommandKHR* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+}
+
+void transform_fromhost_VkTraceRaysIndirectCommandKHR(VkDecoderGlobalState* resourceTracker,
+ VkTraceRaysIndirectCommandKHR* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+}
+
+#endif
void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
void* structExtension_out) {
if (!structExtension_out) {
@@ -9165,6 +9367,14 @@
break;
}
#endif
+#ifdef VK_KHR_pipeline_library
+ case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
+ transform_tohost_VkPipelineLibraryCreateInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkPipelineLibraryCreateInfoKHR*>(structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_KHR_synchronization2
case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
transform_tohost_VkQueueFamilyCheckpointProperties2NV(
@@ -9602,6 +9812,20 @@
break;
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
+ transform_tohost_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
+ structExtension_out));
+ break;
+ }
+#endif
default: {
return;
}
@@ -10347,6 +10571,14 @@
break;
}
#endif
+#ifdef VK_KHR_pipeline_library
+ case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
+ transform_fromhost_VkPipelineLibraryCreateInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkPipelineLibraryCreateInfoKHR*>(structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_KHR_synchronization2
case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
transform_fromhost_VkQueueFamilyCheckpointProperties2NV(
@@ -10784,6 +11016,20 @@
break;
}
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
+ structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
+ transform_fromhost_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
+ structExtension_out));
+ break;
+ }
+#endif
default: {
return;
}
diff --git a/host/vulkan/cereal/common/goldfish_vk_transform.h b/host/vulkan/cereal/common/goldfish_vk_transform.h
index 940be57..45358d5 100644
--- a/host/vulkan/cereal/common/goldfish_vk_transform.h
+++ b/host/vulkan/cereal/common/goldfish_vk_transform.h
@@ -2499,6 +2499,14 @@
transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR)
#endif
+#ifdef VK_KHR_pipeline_library
+void transform_tohost_VkPipelineLibraryCreateInfoKHR(VkDecoderGlobalState* resourceTracker,
+ VkPipelineLibraryCreateInfoKHR* toTransform);
+
+void transform_fromhost_VkPipelineLibraryCreateInfoKHR(VkDecoderGlobalState* resourceTracker,
+ VkPipelineLibraryCreateInfoKHR* toTransform);
+
+#endif
#ifdef VK_KHR_synchronization2
DEFINE_ALIAS_FUNCTION(transform_tohost_VkMemoryBarrier2, transform_tohost_VkMemoryBarrier2KHR)
@@ -3390,5 +3398,53 @@
VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* toTransform);
#endif
+#ifdef VK_KHR_ray_tracing_pipeline
+void transform_tohost_VkRayTracingShaderGroupCreateInfoKHR(
+ VkDecoderGlobalState* resourceTracker, VkRayTracingShaderGroupCreateInfoKHR* toTransform);
+
+void transform_fromhost_VkRayTracingShaderGroupCreateInfoKHR(
+ VkDecoderGlobalState* resourceTracker, VkRayTracingShaderGroupCreateInfoKHR* toTransform);
+
+void transform_tohost_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ VkDecoderGlobalState* resourceTracker, VkRayTracingPipelineInterfaceCreateInfoKHR* toTransform);
+
+void transform_fromhost_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ VkDecoderGlobalState* resourceTracker, VkRayTracingPipelineInterfaceCreateInfoKHR* toTransform);
+
+void transform_tohost_VkRayTracingPipelineCreateInfoKHR(
+ VkDecoderGlobalState* resourceTracker, VkRayTracingPipelineCreateInfoKHR* toTransform);
+
+void transform_fromhost_VkRayTracingPipelineCreateInfoKHR(
+ VkDecoderGlobalState* resourceTracker, VkRayTracingPipelineCreateInfoKHR* toTransform);
+
+void transform_tohost_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ VkDecoderGlobalState* resourceTracker,
+ VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ VkDecoderGlobalState* resourceTracker,
+ VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toTransform);
+
+void transform_tohost_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ VkDecoderGlobalState* resourceTracker,
+ VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ VkDecoderGlobalState* resourceTracker,
+ VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toTransform);
+
+void transform_tohost_VkStridedDeviceAddressRegionKHR(VkDecoderGlobalState* resourceTracker,
+ VkStridedDeviceAddressRegionKHR* toTransform);
+
+void transform_fromhost_VkStridedDeviceAddressRegionKHR(
+ VkDecoderGlobalState* resourceTracker, VkStridedDeviceAddressRegionKHR* toTransform);
+
+void transform_tohost_VkTraceRaysIndirectCommandKHR(VkDecoderGlobalState* resourceTracker,
+ VkTraceRaysIndirectCommandKHR* toTransform);
+
+void transform_fromhost_VkTraceRaysIndirectCommandKHR(VkDecoderGlobalState* resourceTracker,
+ VkTraceRaysIndirectCommandKHR* toTransform);
+
+#endif
} // namespace vk
} // namespace gfxstream
diff --git a/host/vulkan/vulkan_gfxstream.h b/host/vulkan/vulkan_gfxstream.h
index 013f6a8..a7ac22b 100644
--- a/host/vulkan/vulkan_gfxstream.h
+++ b/host/vulkan/vulkan_gfxstream.h
@@ -69,8 +69,7 @@
typedef VkResult (VKAPI_PTR *PFN_vkGetBlobGOOGLE)(VkDevice device, VkDeviceMemory memory);
typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateSized2GOOGLE)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount, uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount, const uint32_t* pImageInfoEntryIndices, const uint32_t* pBufferInfoEntryIndices, const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews, const uint8_t* pInlineUniformBlockData);
typedef void (VKAPI_PTR *PFN_vkQueueSubmitAsync2GOOGLE)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence);
-typedef VkResult(VKAPI_PTR* PFN_vkGetSemaphoreGOOGLE)(VkDevice device, VkSemaphore semaphore,
- uint64_t guestHandleTypes, uint64_t syncId);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreGOOGLE)(VkDevice device, VkSemaphore semaphore, uint64_t syncId);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkMapMemoryIntoAddressSpaceGOOGLE(
@@ -230,8 +229,10 @@
const VkSubmitInfo2* pSubmits,
VkFence fence);
-VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreGOOGLE(VkDevice device, VkSemaphore semaphore,
- uint64_t guestHandleTypes, uint64_t syncId);
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreGOOGLE(
+ VkDevice device,
+ VkSemaphore semaphore,
+ uint64_t syncId);
#endif
#ifdef __cplusplus
