| //////////////////////////////////////////////////////////////////////////////// |
| // Automatically generated file. Do not modify! |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| |
| |
| #include "vulkan_gfx_api.h" |
| |
| #include "interpreter.h" |
| #include "stack.h" |
| |
| #include "vulkan_layers/vk_virtual_swapchain/virtual_swapchain.h" |
| |
| #include <gapic/get_vulkan_proc_address.h> |
| #include <gapic/log.h> |
| |
| #include <vector> |
| #ifdef _WIN32 |
| #define alloca _alloca |
| #else |
| #include <alloca.h> |
| #endif |
| |
| #define __STDC_FORMAT_MACROS |
| #include <inttypes.h> |
| |
| namespace gapir { |
| |
| namespace { |
| |
| std::vector<Vulkan::VkPhysicalDevice> getVkPhysicalDevices(Vulkan::PFNVKENUMERATEPHYSICALDEVICES vkEnumeratePhysicalDevices, Vulkan::VkInstance instance) { |
| uint32_t count = 0; |
| vkEnumeratePhysicalDevices(instance, &count, nullptr); |
| std::vector<Vulkan::VkPhysicalDevice> devices(count); |
| vkEnumeratePhysicalDevices(instance, &count, devices.data()); |
| return devices; |
| } |
| |
| std::vector<Vulkan::VkQueue> getVkQueues(Vulkan::PFNVKGETDEVICEQUEUE vkGetDeviceQueue, Vulkan::VkDevice device, Vulkan::VkDeviceCreateInfo* createInfo) { |
| std::vector<Vulkan::VkQueue> queues; |
| for (uint32_t i = 0; i < createInfo->queueCreateInfoCount; ++i) { |
| auto& queueCreateInfo = createInfo->pQueueCreateInfos[i]; |
| for (uint32_t j = 0; j < queueCreateInfo.queueCount; ++j) { |
| queues.push_back({}); |
| vkGetDeviceQueue(device, queueCreateInfo.queueFamilyIndex, j, &queues.back()); |
| } |
| } |
| return queues; |
| } |
| |
| } // anonymous namespace |
| |
| bool Vulkan::replayCreateVkInstance(Stack* stack, bool pushReturn) { |
| auto pInstance = stack->pop<VkInstance*>(); |
| auto pAllocator = stack->pop<VkAllocationCallbacks*>(); |
| auto pCreateInfo = stack->pop<VkInstanceCreateInfo*>(); |
| // Inject "VirtualSwapchain" into the enabled layer name list by |
| // substituting "VkGraphicsSpy" used for capturing. |
| char virtualSwapchainName[] = "VirtualSwapchain"; |
| const auto count = pCreateInfo->enabledLayerCount; |
| char** layers = static_cast<char**>(alloca((count + 2) * sizeof(char*))); |
| bool has_spy = false; |
| for (size_t i = 0; i < count; ++i) { |
| if (strcmp("VkGraphicsSpy", pCreateInfo->ppEnabledLayerNames[i]) == 0) { |
| pCreateInfo->ppEnabledLayerNames[i] = virtualSwapchainName; |
| has_spy = true; |
| } |
| layers[i] = pCreateInfo->ppEnabledLayerNames[i]; |
| } |
| if (!has_spy) { |
| layers[count] = virtualSwapchainName; |
| pCreateInfo->enabledLayerCount = count + 1; |
| } |
| pCreateInfo->ppEnabledLayerNames = layers; |
| // We recorded pNext during capturing since we turned on VkGraphicsSpy layer. |
| // On the replay side, since there are no extensions that can use pNext yet, |
| // null it out. |
| pCreateInfo->pNext = nullptr; |
| // Push back to the stack, so the acutal function for calling |
| // vkCreateInstance can use it. |
| stack->push(pCreateInfo); |
| stack->push(pAllocator); |
| stack->push(pInstance); |
| return callVkCreateInstance(stack, pushReturn); |
| } |
| |
| bool Vulkan::replayCreateVkDevice(Stack* stack, bool pushReturn) { |
| auto pDevice = stack->pop<VkDevice*>(); |
| auto pAllocator = stack->pop<VkAllocationCallbacks*>(); |
| auto pCreateInfo = stack->pop<VkDeviceCreateInfo*>(); |
| // We recorded pNext during capturing since we turned on VkGraphicsSpy layer. |
| // On the replay side, since there are no extensions that can use pNext yet, |
| // null it out. |
| pCreateInfo->pNext = nullptr; |
| // Push back to the stack, so the acutal function for calling |
| // vkCreateDevice can use it. |
| stack->push(pCreateInfo); |
| stack->push(pAllocator); |
| stack->push(pDevice); |
| return callVkCreateDevice(stack, pushReturn); |
| } |
| |
| bool Vulkan::replayRegisterVkInstance(Stack* stack) { |
| auto instance = static_cast<VkInstance>(stack->pop<size_val>()); |
| if (stack->isValid()) { |
| GAPID_INFO("replayRegisterVkInstance(%" PRIu64 ")", instance); |
| if (mVkInstanceFunctionStubs.count(instance) > 0) { |
| // TODO(antiagainst): The same instance handle returned from the driver. Is this possible? |
| return false; |
| } |
| auto& stubs = mVkInstanceFunctionStubs[instance]; |
| stubs.vkCreateAndroidSurfaceKHR = reinterpret_cast<PFNVKCREATEANDROIDSURFACEKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkCreateAndroidSurfaceKHR", false)); |
| stubs.vkCreateXlibSurfaceKHR = reinterpret_cast<PFNVKCREATEXLIBSURFACEKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkCreateXlibSurfaceKHR", false)); |
| stubs.vkGetPhysicalDeviceXlibPresentationSupportKHR = reinterpret_cast<PFNVKGETPHYSICALDEVICEXLIBPRESENTATIONSUPPORTKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR", false)); |
| stubs.vkCreateXcbSurfaceKHR = reinterpret_cast<PFNVKCREATEXCBSURFACEKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkCreateXcbSurfaceKHR", false)); |
| stubs.vkGetPhysicalDeviceXcbPresentationSupportKHR = reinterpret_cast<PFNVKGETPHYSICALDEVICEXCBPRESENTATIONSUPPORTKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR", false)); |
| stubs.vkCreateWaylandSurfaceKHR = reinterpret_cast<PFNVKCREATEWAYLANDSURFACEKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkCreateWaylandSurfaceKHR", false)); |
| stubs.vkGetPhysicalDeviceWaylandPresentationSupportKHR = reinterpret_cast<PFNVKGETPHYSICALDEVICEWAYLANDPRESENTATIONSUPPORTKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR", false)); |
| stubs.vkCreateMirSurfaceKHR = reinterpret_cast<PFNVKCREATEMIRSURFACEKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkCreateMirSurfaceKHR", false)); |
| stubs.vkGetPhysicalDeviceMirPresentationSupportKHR = reinterpret_cast<PFNVKGETPHYSICALDEVICEMIRPRESENTATIONSUPPORTKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceMirPresentationSupportKHR", false)); |
| stubs.vkDestroyInstance = reinterpret_cast<PFNVKDESTROYINSTANCE>(gapic::GetVulkanInstanceProcAddress(instance, "vkDestroyInstance", false)); |
| stubs.vkEnumeratePhysicalDevices = reinterpret_cast<PFNVKENUMERATEPHYSICALDEVICES>(gapic::GetVulkanInstanceProcAddress(instance, "vkEnumeratePhysicalDevices", false)); |
| stubs.vkGetPhysicalDeviceFeatures = reinterpret_cast<PFNVKGETPHYSICALDEVICEFEATURES>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceFeatures", false)); |
| stubs.vkGetPhysicalDeviceFormatProperties = reinterpret_cast<PFNVKGETPHYSICALDEVICEFORMATPROPERTIES>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceFormatProperties", false)); |
| stubs.vkGetPhysicalDeviceImageFormatProperties = reinterpret_cast<PFNVKGETPHYSICALDEVICEIMAGEFORMATPROPERTIES>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceImageFormatProperties", false)); |
| stubs.vkGetPhysicalDeviceProperties = reinterpret_cast<PFNVKGETPHYSICALDEVICEPROPERTIES>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceProperties", false)); |
| stubs.vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFNVKGETPHYSICALDEVICEQUEUEFAMILYPROPERTIES>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceQueueFamilyProperties", false)); |
| stubs.vkGetPhysicalDeviceMemoryProperties = reinterpret_cast<PFNVKGETPHYSICALDEVICEMEMORYPROPERTIES>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceMemoryProperties", false)); |
| stubs.vkGetInstanceProcAddr = reinterpret_cast<PFNVKGETINSTANCEPROCADDR>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetInstanceProcAddr", false)); |
| stubs.vkCreateDevice = reinterpret_cast<PFNVKCREATEDEVICE>(gapic::GetVulkanInstanceProcAddress(instance, "vkCreateDevice", false)); |
| stubs.vkEnumerateDeviceExtensionProperties = reinterpret_cast<PFNVKENUMERATEDEVICEEXTENSIONPROPERTIES>(gapic::GetVulkanInstanceProcAddress(instance, "vkEnumerateDeviceExtensionProperties", false)); |
| stubs.vkEnumerateDeviceLayerProperties = reinterpret_cast<PFNVKENUMERATEDEVICELAYERPROPERTIES>(gapic::GetVulkanInstanceProcAddress(instance, "vkEnumerateDeviceLayerProperties", false)); |
| stubs.vkGetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast<PFNVKGETPHYSICALDEVICESPARSEIMAGEFORMATPROPERTIES>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceSparseImageFormatProperties", false)); |
| stubs.vkDestroySurfaceKHR = reinterpret_cast<PFNVKDESTROYSURFACEKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkDestroySurfaceKHR", false)); |
| stubs.vkGetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFNVKGETPHYSICALDEVICESURFACESUPPORTKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceSurfaceSupportKHR", false)); |
| stubs.vkGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFNVKGETPHYSICALDEVICESURFACECAPABILITIESKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", false)); |
| stubs.vkGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFNVKGETPHYSICALDEVICESURFACEFORMATSKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR", false)); |
| stubs.vkGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFNVKGETPHYSICALDEVICESURFACEPRESENTMODESKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR", false)); |
| stubs.vkGetPhysicalDeviceDisplayPropertiesKHR = reinterpret_cast<PFNVKGETPHYSICALDEVICEDISPLAYPROPERTIESKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceDisplayPropertiesKHR", false)); |
| stubs.vkGetPhysicalDeviceDisplayPlanePropertiesKHR = reinterpret_cast<PFNVKGETPHYSICALDEVICEDISPLAYPLANEPROPERTIESKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR", false)); |
| stubs.vkGetDisplayPlaneSupportedDisplaysKHR = reinterpret_cast<PFNVKGETDISPLAYPLANESUPPORTEDDISPLAYSKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetDisplayPlaneSupportedDisplaysKHR", false)); |
| stubs.vkGetDisplayModePropertiesKHR = reinterpret_cast<PFNVKGETDISPLAYMODEPROPERTIESKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetDisplayModePropertiesKHR", false)); |
| stubs.vkCreateDisplayModeKHR = reinterpret_cast<PFNVKCREATEDISPLAYMODEKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkCreateDisplayModeKHR", false)); |
| stubs.vkGetDisplayPlaneCapabilitiesKHR = reinterpret_cast<PFNVKGETDISPLAYPLANECAPABILITIESKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkGetDisplayPlaneCapabilitiesKHR", false)); |
| stubs.vkCreateDisplayPlaneSurfaceKHR = reinterpret_cast<PFNVKCREATEDISPLAYPLANESURFACEKHR>(gapic::GetVulkanInstanceProcAddress(instance, "vkCreateDisplayPlaneSurfaceKHR", false)); |
| stubs.vkCreateDebugReportCallbackEXT = reinterpret_cast<PFNVKCREATEDEBUGREPORTCALLBACKEXT>(gapic::GetVulkanInstanceProcAddress(instance, "vkCreateDebugReportCallbackEXT", false)); |
| stubs.vkDestroyDebugReportCallbackEXT = reinterpret_cast<PFNVKDESTROYDEBUGREPORTCALLBACKEXT>(gapic::GetVulkanInstanceProcAddress(instance, "vkDestroyDebugReportCallbackEXT", false)); |
| stubs.vkDebugReportMessageEXT = reinterpret_cast<PFNVKDEBUGREPORTMESSAGEEXT>(gapic::GetVulkanInstanceProcAddress(instance, "vkDebugReportMessageEXT", false)); |
| // Get all physical devices for this instance and bind them. |
| for (auto phydev : getVkPhysicalDevices(stubs.vkEnumeratePhysicalDevices, instance)) { |
| mIndirectMaps.VkPhysicalDevicesToVkInstances[phydev] = instance; |
| } |
| return true; |
| } else { |
| GAPID_WARNING("Error during calling function replayRegisterVkInstance"); |
| return false; |
| } |
| } |
| |
| bool Vulkan::replayUnregisterVkInstance(Stack* stack) { |
| auto instance = static_cast<VkInstance>(stack->pop<size_val>()); |
| if (stack->isValid()) { |
| GAPID_INFO("replayUnregisterVkInstance(%" PRIu64 ")", instance); |
| mVkInstanceFunctionStubs.erase(instance); |
| auto& pdevMap = mIndirectMaps.VkPhysicalDevicesToVkInstances; |
| for (auto it = pdevMap.begin(); it != pdevMap.end();) { |
| if (it->second == instance) { |
| it = pdevMap.erase(it); |
| } else { |
| ++it; |
| } |
| } |
| return true; |
| } else { |
| GAPID_WARNING("Error during calling function replayUnregisterVkInstance"); |
| return false; |
| } |
| } |
| |
| bool Vulkan::replayRegisterVkDevice(Stack* stack) { |
| auto createInfo = stack->pop<VkDeviceCreateInfo*>(); |
| auto device = static_cast<VkDevice>(stack->pop<size_val>()); |
| auto physical_device = static_cast<VkPhysicalDevice>(stack->pop<size_val>()); |
| if (stack->isValid()) { |
| GAPID_INFO("replayRegisterVkDevice(%" PRIu64 ", %" PRIu64 ", %p)", physical_device, device, createInfo); |
| if (mVkDeviceFunctionStubs.count(device) > 0) { |
| // TODO(antiagainst): The same device handle returned from the driver. Is this possible? |
| return false; |
| } |
| mIndirectMaps.VkDevicesToVkPhysicalDevices[device] = physical_device; |
| auto instance = mIndirectMaps.VkPhysicalDevicesToVkInstances[physical_device]; |
| auto& stubs = mVkDeviceFunctionStubs[device]; |
| stubs.vkGetSwapchainGrallocUsageANDROID = reinterpret_cast<PFNVKGETSWAPCHAINGRALLOCUSAGEANDROID>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkGetSwapchainGrallocUsageANDROID", false)); |
| stubs.vkAcquireImageANDROID = reinterpret_cast<PFNVKACQUIREIMAGEANDROID>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkAcquireImageANDROID", false)); |
| stubs.vkQueueSignalReleaseImageANDROID = reinterpret_cast<PFNVKQUEUESIGNALRELEASEIMAGEANDROID>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkQueueSignalReleaseImageANDROID", false)); |
| stubs.vkGetDeviceProcAddr = reinterpret_cast<PFNVKGETDEVICEPROCADDR>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkGetDeviceProcAddr", false)); |
| stubs.vkDestroyDevice = reinterpret_cast<PFNVKDESTROYDEVICE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyDevice", false)); |
| stubs.vkGetDeviceQueue = reinterpret_cast<PFNVKGETDEVICEQUEUE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkGetDeviceQueue", false)); |
| stubs.vkQueueSubmit = reinterpret_cast<PFNVKQUEUESUBMIT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkQueueSubmit", false)); |
| stubs.vkQueueWaitIdle = reinterpret_cast<PFNVKQUEUEWAITIDLE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkQueueWaitIdle", false)); |
| stubs.vkDeviceWaitIdle = reinterpret_cast<PFNVKDEVICEWAITIDLE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDeviceWaitIdle", false)); |
| stubs.vkAllocateMemory = reinterpret_cast<PFNVKALLOCATEMEMORY>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkAllocateMemory", false)); |
| stubs.vkFreeMemory = reinterpret_cast<PFNVKFREEMEMORY>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkFreeMemory", false)); |
| stubs.vkMapMemory = reinterpret_cast<PFNVKMAPMEMORY>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkMapMemory", false)); |
| stubs.vkUnmapMemory = reinterpret_cast<PFNVKUNMAPMEMORY>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkUnmapMemory", false)); |
| stubs.vkFlushMappedMemoryRanges = reinterpret_cast<PFNVKFLUSHMAPPEDMEMORYRANGES>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkFlushMappedMemoryRanges", false)); |
| stubs.vkInvalidateMappedMemoryRanges = reinterpret_cast<PFNVKINVALIDATEMAPPEDMEMORYRANGES>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkInvalidateMappedMemoryRanges", false)); |
| stubs.vkGetDeviceMemoryCommitment = reinterpret_cast<PFNVKGETDEVICEMEMORYCOMMITMENT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkGetDeviceMemoryCommitment", false)); |
| stubs.vkBindBufferMemory = reinterpret_cast<PFNVKBINDBUFFERMEMORY>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkBindBufferMemory", false)); |
| stubs.vkBindImageMemory = reinterpret_cast<PFNVKBINDIMAGEMEMORY>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkBindImageMemory", false)); |
| stubs.vkGetBufferMemoryRequirements = reinterpret_cast<PFNVKGETBUFFERMEMORYREQUIREMENTS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkGetBufferMemoryRequirements", false)); |
| stubs.vkGetImageMemoryRequirements = reinterpret_cast<PFNVKGETIMAGEMEMORYREQUIREMENTS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkGetImageMemoryRequirements", false)); |
| stubs.vkGetImageSparseMemoryRequirements = reinterpret_cast<PFNVKGETIMAGESPARSEMEMORYREQUIREMENTS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkGetImageSparseMemoryRequirements", false)); |
| stubs.vkQueueBindSparse = reinterpret_cast<PFNVKQUEUEBINDSPARSE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkQueueBindSparse", false)); |
| stubs.vkCreateFence = reinterpret_cast<PFNVKCREATEFENCE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateFence", false)); |
| stubs.vkDestroyFence = reinterpret_cast<PFNVKDESTROYFENCE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyFence", false)); |
| stubs.vkResetFences = reinterpret_cast<PFNVKRESETFENCES>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkResetFences", false)); |
| stubs.vkGetFenceStatus = reinterpret_cast<PFNVKGETFENCESTATUS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkGetFenceStatus", false)); |
| stubs.vkWaitForFences = reinterpret_cast<PFNVKWAITFORFENCES>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkWaitForFences", false)); |
| stubs.vkCreateSemaphore = reinterpret_cast<PFNVKCREATESEMAPHORE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateSemaphore", false)); |
| stubs.vkDestroySemaphore = reinterpret_cast<PFNVKDESTROYSEMAPHORE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroySemaphore", false)); |
| stubs.vkCreateEvent = reinterpret_cast<PFNVKCREATEEVENT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateEvent", false)); |
| stubs.vkDestroyEvent = reinterpret_cast<PFNVKDESTROYEVENT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyEvent", false)); |
| stubs.vkGetEventStatus = reinterpret_cast<PFNVKGETEVENTSTATUS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkGetEventStatus", false)); |
| stubs.vkSetEvent = reinterpret_cast<PFNVKSETEVENT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkSetEvent", false)); |
| stubs.vkResetEvent = reinterpret_cast<PFNVKRESETEVENT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkResetEvent", false)); |
| stubs.vkCreateQueryPool = reinterpret_cast<PFNVKCREATEQUERYPOOL>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateQueryPool", false)); |
| stubs.vkDestroyQueryPool = reinterpret_cast<PFNVKDESTROYQUERYPOOL>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyQueryPool", false)); |
| stubs.vkGetQueryPoolResults = reinterpret_cast<PFNVKGETQUERYPOOLRESULTS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkGetQueryPoolResults", false)); |
| stubs.vkCreateBuffer = reinterpret_cast<PFNVKCREATEBUFFER>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateBuffer", false)); |
| stubs.vkDestroyBuffer = reinterpret_cast<PFNVKDESTROYBUFFER>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyBuffer", false)); |
| stubs.vkCreateBufferView = reinterpret_cast<PFNVKCREATEBUFFERVIEW>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateBufferView", false)); |
| stubs.vkDestroyBufferView = reinterpret_cast<PFNVKDESTROYBUFFERVIEW>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyBufferView", false)); |
| stubs.vkCreateImage = reinterpret_cast<PFNVKCREATEIMAGE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateImage", false)); |
| stubs.vkDestroyImage = reinterpret_cast<PFNVKDESTROYIMAGE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyImage", false)); |
| stubs.vkGetImageSubresourceLayout = reinterpret_cast<PFNVKGETIMAGESUBRESOURCELAYOUT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkGetImageSubresourceLayout", false)); |
| stubs.vkCreateImageView = reinterpret_cast<PFNVKCREATEIMAGEVIEW>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateImageView", false)); |
| stubs.vkDestroyImageView = reinterpret_cast<PFNVKDESTROYIMAGEVIEW>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyImageView", false)); |
| stubs.vkCreateShaderModule = reinterpret_cast<PFNVKCREATESHADERMODULE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateShaderModule", false)); |
| stubs.vkDestroyShaderModule = reinterpret_cast<PFNVKDESTROYSHADERMODULE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyShaderModule", false)); |
| stubs.vkCreatePipelineCache = reinterpret_cast<PFNVKCREATEPIPELINECACHE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreatePipelineCache", false)); |
| stubs.vkDestroyPipelineCache = reinterpret_cast<PFNVKDESTROYPIPELINECACHE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyPipelineCache", false)); |
| stubs.vkGetPipelineCacheData = reinterpret_cast<PFNVKGETPIPELINECACHEDATA>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkGetPipelineCacheData", false)); |
| stubs.vkMergePipelineCaches = reinterpret_cast<PFNVKMERGEPIPELINECACHES>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkMergePipelineCaches", false)); |
| stubs.vkCreateGraphicsPipelines = reinterpret_cast<PFNVKCREATEGRAPHICSPIPELINES>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateGraphicsPipelines", false)); |
| stubs.vkCreateComputePipelines = reinterpret_cast<PFNVKCREATECOMPUTEPIPELINES>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateComputePipelines", false)); |
| stubs.vkDestroyPipeline = reinterpret_cast<PFNVKDESTROYPIPELINE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyPipeline", false)); |
| stubs.vkCreatePipelineLayout = reinterpret_cast<PFNVKCREATEPIPELINELAYOUT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreatePipelineLayout", false)); |
| stubs.vkDestroyPipelineLayout = reinterpret_cast<PFNVKDESTROYPIPELINELAYOUT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyPipelineLayout", false)); |
| stubs.vkCreateSampler = reinterpret_cast<PFNVKCREATESAMPLER>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateSampler", false)); |
| stubs.vkDestroySampler = reinterpret_cast<PFNVKDESTROYSAMPLER>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroySampler", false)); |
| stubs.vkCreateDescriptorSetLayout = reinterpret_cast<PFNVKCREATEDESCRIPTORSETLAYOUT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateDescriptorSetLayout", false)); |
| stubs.vkDestroyDescriptorSetLayout = reinterpret_cast<PFNVKDESTROYDESCRIPTORSETLAYOUT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyDescriptorSetLayout", false)); |
| stubs.vkCreateDescriptorPool = reinterpret_cast<PFNVKCREATEDESCRIPTORPOOL>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateDescriptorPool", false)); |
| stubs.vkDestroyDescriptorPool = reinterpret_cast<PFNVKDESTROYDESCRIPTORPOOL>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyDescriptorPool", false)); |
| stubs.vkResetDescriptorPool = reinterpret_cast<PFNVKRESETDESCRIPTORPOOL>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkResetDescriptorPool", false)); |
| stubs.vkAllocateDescriptorSets = reinterpret_cast<PFNVKALLOCATEDESCRIPTORSETS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkAllocateDescriptorSets", false)); |
| stubs.vkFreeDescriptorSets = reinterpret_cast<PFNVKFREEDESCRIPTORSETS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkFreeDescriptorSets", false)); |
| stubs.vkUpdateDescriptorSets = reinterpret_cast<PFNVKUPDATEDESCRIPTORSETS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkUpdateDescriptorSets", false)); |
| stubs.vkCreateFramebuffer = reinterpret_cast<PFNVKCREATEFRAMEBUFFER>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateFramebuffer", false)); |
| stubs.vkDestroyFramebuffer = reinterpret_cast<PFNVKDESTROYFRAMEBUFFER>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyFramebuffer", false)); |
| stubs.vkCreateRenderPass = reinterpret_cast<PFNVKCREATERENDERPASS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateRenderPass", false)); |
| stubs.vkDestroyRenderPass = reinterpret_cast<PFNVKDESTROYRENDERPASS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyRenderPass", false)); |
| stubs.vkGetRenderAreaGranularity = reinterpret_cast<PFNVKGETRENDERAREAGRANULARITY>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkGetRenderAreaGranularity", false)); |
| stubs.vkCreateCommandPool = reinterpret_cast<PFNVKCREATECOMMANDPOOL>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateCommandPool", false)); |
| stubs.vkDestroyCommandPool = reinterpret_cast<PFNVKDESTROYCOMMANDPOOL>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroyCommandPool", false)); |
| stubs.vkResetCommandPool = reinterpret_cast<PFNVKRESETCOMMANDPOOL>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkResetCommandPool", false)); |
| stubs.vkAllocateCommandBuffers = reinterpret_cast<PFNVKALLOCATECOMMANDBUFFERS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkAllocateCommandBuffers", false)); |
| stubs.vkFreeCommandBuffers = reinterpret_cast<PFNVKFREECOMMANDBUFFERS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkFreeCommandBuffers", false)); |
| stubs.vkBeginCommandBuffer = reinterpret_cast<PFNVKBEGINCOMMANDBUFFER>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkBeginCommandBuffer", false)); |
| stubs.vkEndCommandBuffer = reinterpret_cast<PFNVKENDCOMMANDBUFFER>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkEndCommandBuffer", false)); |
| stubs.vkResetCommandBuffer = reinterpret_cast<PFNVKRESETCOMMANDBUFFER>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkResetCommandBuffer", false)); |
| stubs.vkCmdBindPipeline = reinterpret_cast<PFNVKCMDBINDPIPELINE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdBindPipeline", false)); |
| stubs.vkCmdSetViewport = reinterpret_cast<PFNVKCMDSETVIEWPORT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdSetViewport", false)); |
| stubs.vkCmdSetScissor = reinterpret_cast<PFNVKCMDSETSCISSOR>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdSetScissor", false)); |
| stubs.vkCmdSetLineWidth = reinterpret_cast<PFNVKCMDSETLINEWIDTH>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdSetLineWidth", false)); |
| stubs.vkCmdSetDepthBias = reinterpret_cast<PFNVKCMDSETDEPTHBIAS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdSetDepthBias", false)); |
| stubs.vkCmdSetBlendConstants = reinterpret_cast<PFNVKCMDSETBLENDCONSTANTS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdSetBlendConstants", false)); |
| stubs.vkCmdSetDepthBounds = reinterpret_cast<PFNVKCMDSETDEPTHBOUNDS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdSetDepthBounds", false)); |
| stubs.vkCmdSetStencilCompareMask = reinterpret_cast<PFNVKCMDSETSTENCILCOMPAREMASK>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdSetStencilCompareMask", false)); |
| stubs.vkCmdSetStencilWriteMask = reinterpret_cast<PFNVKCMDSETSTENCILWRITEMASK>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdSetStencilWriteMask", false)); |
| stubs.vkCmdSetStencilReference = reinterpret_cast<PFNVKCMDSETSTENCILREFERENCE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdSetStencilReference", false)); |
| stubs.vkCmdBindDescriptorSets = reinterpret_cast<PFNVKCMDBINDDESCRIPTORSETS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdBindDescriptorSets", false)); |
| stubs.vkCmdBindIndexBuffer = reinterpret_cast<PFNVKCMDBINDINDEXBUFFER>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdBindIndexBuffer", false)); |
| stubs.vkCmdBindVertexBuffers = reinterpret_cast<PFNVKCMDBINDVERTEXBUFFERS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdBindVertexBuffers", false)); |
| stubs.vkCmdDraw = reinterpret_cast<PFNVKCMDDRAW>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdDraw", false)); |
| stubs.vkCmdDrawIndexed = reinterpret_cast<PFNVKCMDDRAWINDEXED>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdDrawIndexed", false)); |
| stubs.vkCmdDrawIndirect = reinterpret_cast<PFNVKCMDDRAWINDIRECT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdDrawIndirect", false)); |
| stubs.vkCmdDrawIndexedIndirect = reinterpret_cast<PFNVKCMDDRAWINDEXEDINDIRECT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdDrawIndexedIndirect", false)); |
| stubs.vkCmdDispatch = reinterpret_cast<PFNVKCMDDISPATCH>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdDispatch", false)); |
| stubs.vkCmdDispatchIndirect = reinterpret_cast<PFNVKCMDDISPATCHINDIRECT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdDispatchIndirect", false)); |
| stubs.vkCmdCopyBuffer = reinterpret_cast<PFNVKCMDCOPYBUFFER>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdCopyBuffer", false)); |
| stubs.vkCmdCopyImage = reinterpret_cast<PFNVKCMDCOPYIMAGE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdCopyImage", false)); |
| stubs.vkCmdBlitImage = reinterpret_cast<PFNVKCMDBLITIMAGE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdBlitImage", false)); |
| stubs.vkCmdCopyBufferToImage = reinterpret_cast<PFNVKCMDCOPYBUFFERTOIMAGE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdCopyBufferToImage", false)); |
| stubs.vkCmdCopyImageToBuffer = reinterpret_cast<PFNVKCMDCOPYIMAGETOBUFFER>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdCopyImageToBuffer", false)); |
| stubs.vkCmdUpdateBuffer = reinterpret_cast<PFNVKCMDUPDATEBUFFER>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdUpdateBuffer", false)); |
| stubs.vkCmdFillBuffer = reinterpret_cast<PFNVKCMDFILLBUFFER>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdFillBuffer", false)); |
| stubs.vkCmdClearColorImage = reinterpret_cast<PFNVKCMDCLEARCOLORIMAGE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdClearColorImage", false)); |
| stubs.vkCmdClearDepthStencilImage = reinterpret_cast<PFNVKCMDCLEARDEPTHSTENCILIMAGE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdClearDepthStencilImage", false)); |
| stubs.vkCmdClearAttachments = reinterpret_cast<PFNVKCMDCLEARATTACHMENTS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdClearAttachments", false)); |
| stubs.vkCmdResolveImage = reinterpret_cast<PFNVKCMDRESOLVEIMAGE>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdResolveImage", false)); |
| stubs.vkCmdSetEvent = reinterpret_cast<PFNVKCMDSETEVENT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdSetEvent", false)); |
| stubs.vkCmdResetEvent = reinterpret_cast<PFNVKCMDRESETEVENT>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdResetEvent", false)); |
| stubs.vkCmdWaitEvents = reinterpret_cast<PFNVKCMDWAITEVENTS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdWaitEvents", false)); |
| stubs.vkCmdPipelineBarrier = reinterpret_cast<PFNVKCMDPIPELINEBARRIER>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdPipelineBarrier", false)); |
| stubs.vkCmdBeginQuery = reinterpret_cast<PFNVKCMDBEGINQUERY>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdBeginQuery", false)); |
| stubs.vkCmdEndQuery = reinterpret_cast<PFNVKCMDENDQUERY>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdEndQuery", false)); |
| stubs.vkCmdResetQueryPool = reinterpret_cast<PFNVKCMDRESETQUERYPOOL>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdResetQueryPool", false)); |
| stubs.vkCmdWriteTimestamp = reinterpret_cast<PFNVKCMDWRITETIMESTAMP>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdWriteTimestamp", false)); |
| stubs.vkCmdCopyQueryPoolResults = reinterpret_cast<PFNVKCMDCOPYQUERYPOOLRESULTS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdCopyQueryPoolResults", false)); |
| stubs.vkCmdPushConstants = reinterpret_cast<PFNVKCMDPUSHCONSTANTS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdPushConstants", false)); |
| stubs.vkCmdBeginRenderPass = reinterpret_cast<PFNVKCMDBEGINRENDERPASS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdBeginRenderPass", false)); |
| stubs.vkCmdNextSubpass = reinterpret_cast<PFNVKCMDNEXTSUBPASS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdNextSubpass", false)); |
| stubs.vkCmdEndRenderPass = reinterpret_cast<PFNVKCMDENDRENDERPASS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdEndRenderPass", false)); |
| stubs.vkCmdExecuteCommands = reinterpret_cast<PFNVKCMDEXECUTECOMMANDS>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCmdExecuteCommands", false)); |
| stubs.vkCreateSwapchainKHR = reinterpret_cast<PFNVKCREATESWAPCHAINKHR>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateSwapchainKHR", false)); |
| stubs.vkDestroySwapchainKHR = reinterpret_cast<PFNVKDESTROYSWAPCHAINKHR>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkDestroySwapchainKHR", false)); |
| stubs.vkGetSwapchainImagesKHR = reinterpret_cast<PFNVKGETSWAPCHAINIMAGESKHR>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkGetSwapchainImagesKHR", false)); |
| stubs.vkAcquireNextImageKHR = reinterpret_cast<PFNVKACQUIRENEXTIMAGEKHR>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkAcquireNextImageKHR", false)); |
| stubs.vkQueuePresentKHR = reinterpret_cast<PFNVKQUEUEPRESENTKHR>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkQueuePresentKHR", false)); |
| stubs.vkCreateSharedSwapchainsKHR = reinterpret_cast<PFNVKCREATESHAREDSWAPCHAINSKHR>(gapic::GetVulkanDeviceProcAddress(instance, device, "vkCreateSharedSwapchainsKHR", false)); |
| // Get all queues for this device and bind them. |
| for (auto queue : getVkQueues(stubs.vkGetDeviceQueue, device, createInfo)) { |
| mIndirectMaps.VkQueuesToVkDevices[queue] = device; |
| } |
| return true; |
| } else { |
| GAPID_WARNING("Error during calling function replayRegisterVkDevice"); |
| return false; |
| } |
| } |
| |
| bool Vulkan::replayUnregisterVkDevice(Stack* stack) { |
| auto device = static_cast<VkDevice>(stack->pop<size_val>()); |
| if (stack->isValid()) { |
| GAPID_INFO("replayUnregisterVkDevice(%" PRIu64 ")", device); |
| mVkDeviceFunctionStubs.erase(device); |
| mIndirectMaps.VkDevicesToVkPhysicalDevices.erase(device); |
| auto& queueMap = mIndirectMaps.VkQueuesToVkDevices; |
| for (auto it = queueMap.begin(); it != queueMap.end();) { |
| if (it->second == device) { |
| it = queueMap.erase(it); |
| } else { |
| ++it; |
| } |
| } |
| auto& cmdbufMap = mIndirectMaps.VkCommandBuffersToVkDevices; |
| for (auto it = cmdbufMap.begin(); it != cmdbufMap.end();) { |
| if (it->second == device) { |
| it = cmdbufMap.erase(it); |
| } else { |
| ++it; |
| } |
| } |
| return true; |
| } else { |
| GAPID_WARNING("Error during calling function replayUnregisterVkDevice"); |
| return false; |
| } |
| } |
| |
| bool Vulkan::replayRegisterVkCommandBuffers(Stack* stack) { |
| auto commandBuffers = stack->pop<VkCommandBuffer*>(); |
| auto count = stack->pop<uint32_t>(); |
| auto device = static_cast<VkDevice>(stack->pop<size_val>()); |
| if (stack->isValid()) { |
| GAPID_INFO("replayRegisterVkCommandBuffers(%" PRIu64 ", %" PRIu32 ", %p)", device, count, commandBuffers); |
| for (uint32_t i = 0; i < count; ++i) { |
| mIndirectMaps.VkCommandBuffersToVkDevices[commandBuffers[i]] = device; |
| } |
| return true; |
| } else { |
| GAPID_WARNING("Error during calling function replayRegisterVkCommandBuffers"); |
| return false; |
| } |
| } |
| |
| bool Vulkan::replayUnregisterVkCommandBuffers(Stack* stack) { |
| auto commandBuffers = stack->pop<VkCommandBuffer*>(); |
| auto count = stack->pop<uint32_t>(); |
| if (stack->isValid()) { |
| GAPID_INFO("replayUnregisterVkCommandBuffers(%" PRIu32 ", %p)", count, commandBuffers); |
| for (uint32_t i = 0; i < count; ++i) { |
| mIndirectMaps.VkCommandBuffersToVkDevices.erase(commandBuffers[i]); |
| } |
| return true; |
| } else { |
| GAPID_WARNING("Error during calling function replayUnregisterVkCommandBuffers"); |
| return false; |
| } |
| } |
| |
| bool Vulkan::toggleVirtualSwapchainReturnAcquiredImage(Stack* stack) { |
| auto pSwapchain = stack->pop<VkSwapchainKHR*>(); |
| if (stack->isValid()) { |
| GAPID_INFO("toggleVirtualSwapchainReturnAcquiredImage(%" PRIu32 ", %p)", pSwapchain); |
| auto virtual_swapchain = reinterpret_cast<swapchain::VirtualSwapchain*>(*pSwapchain); |
| virtual_swapchain->SetAlwaysGetAcquiredImage(true); |
| return true; |
| } else { |
| GAPID_WARNING("Error during calling function toggleVirtualSwapchainReturnAcquiredImage"); |
| return false; |
| } |
| } |
| |
| namespace { |
| uint32_t getMemoryTypeIndex( |
| const Vulkan::VkPhysicalDeviceMemoryProperties* memory_properties, |
| uint32_t memory_type_bits, Vulkan::VkFlags requirement_bit) { |
| // Search through mem types to find the first index with the required properties |
| for (uint32_t i = 0; i < memory_properties->memoryTypeCount; i++) { |
| if ((memory_type_bits & 1) == 1) { |
| if ((memory_properties->memoryTypes[i].propertyFlags & requirement_bit) == |
| requirement_bit) { |
| return i; |
| } |
| } |
| memory_type_bits >>= 1; |
| } |
| // No memory types matched |
| return UINT32_MAX; |
| } |
| } |
| |
| bool Vulkan::replayAllocateImageMemory(Stack* stack, bool pushReturn) { |
| auto pMemory = stack->pop<VkDeviceMemory*>(); |
| auto image = stack->pop<VkImage>(); |
| auto pPhysicalDeviceMemoryProperties = stack->pop<VkPhysicalDeviceMemoryProperties*>(); |
| auto device = stack->pop<VkDevice>(); |
| if (stack->isValid()) { |
| GAPID_INFO("replayAllocateImageMemory(%zu, %zu, %p", device, image, pMemory); |
| VkMemoryRequirements image_mem_reqs; |
| auto GetImageMemReqFuncPtr = mVkDeviceFunctionStubs[device].vkGetImageMemoryRequirements; |
| GetImageMemReqFuncPtr(device, image, &image_mem_reqs); |
| uint32_t mem_type_index = getMemoryTypeIndex( |
| pPhysicalDeviceMemoryProperties, |
| image_mem_reqs.memoryTypeBits, 0); |
| VkMemoryAllocateInfo allocate_info{ |
| VkStructureType::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, |
| nullptr, |
| image_mem_reqs.size, |
| mem_type_index}; |
| VkDeviceMemory memory; |
| auto AllocateMemoryFuncPtr = mVkDeviceFunctionStubs[device].vkAllocateMemory; |
| VkResult get_alloc_result = AllocateMemoryFuncPtr(device, &allocate_info, nullptr, &memory); |
| pMemory[0] = memory; |
| if (pushReturn) { |
| stack->push<VkResult>(get_alloc_result); |
| } |
| return true; |
| } else { |
| GAPID_WARNING("Error during calling function replayAllocateImageMemory"); |
| return false; |
| } |
| } |
| |
| bool Vulkan::replayGetFenceStatus(Stack* stack, bool pushReturn) { |
| auto success = gapir::Vulkan::VkResult(stack->pop<uint32_t>()); |
| auto fence = stack->pop<uint64_t>(); |
| auto device = static_cast<size_val>(stack->pop<size_val>()); |
| if (stack->isValid()) { |
| GAPID_INFO("vkGetFenceStatus(%zu, %" PRIu64 ")", device, fence); |
| if (mVkDeviceFunctionStubs.find(device) != mVkDeviceFunctionStubs.end() && |
| mVkDeviceFunctionStubs[device].vkGetFenceStatus) { |
| VkResult return_value; |
| if (success == gapir::Vulkan::VkResult::VK_SUCCESS) { |
| return_value = mVkDeviceFunctionStubs[device].vkWaitForFences(device, 1, &fence, 1, 0xFFFFFFFFFFFFFFFF); |
| } else { |
| return_value = mVkDeviceFunctionStubs[device].vkGetFenceStatus(device, fence); |
| } |
| GAPID_INFO("Returned: %u", return_value); |
| if (pushReturn) { |
| stack->push<VkResult>(return_value); |
| } |
| } else { |
| GAPID_WARNING("Attempted to call unsupported function vkGetFenceStatus"); |
| } |
| return true; |
| } else { |
| GAPID_WARNING("Error during calling function vkGetFenceStatus"); |
| return false; |
| } |
| } |
| |
| } // namespace gapir |
