| #include "SwapChainStateVk.h" |
| |
| #include <cinttypes> |
| #include <unordered_set> |
| |
| #include "vulkan/vk_util.h" |
| |
| #define SWAPCHAINSTATE_VK_ERROR(fmt, ...) \ |
| do { \ |
| fprintf(stderr, "%s(%s:%d): " fmt "\n", __func__, __FILE__, __LINE__, \ |
| ##__VA_ARGS__); \ |
| fflush(stderr); \ |
| } while (0) |
| |
| SwapChainStateVk::SwapChainStateVk(const goldfish_vk::VulkanDispatch &vk, |
| VkDevice vkDevice, |
| const VkSwapchainCreateInfoKHR &swapChainCi) |
| : m_vk(vk), |
| m_vkDevice(vkDevice), |
| m_vkSwapChain(VK_NULL_HANDLE), |
| m_vkImages(0), |
| m_vkImageViews(0) { |
| VK_CHECK(m_vk.vkCreateSwapchainKHR(m_vkDevice, &swapChainCi, nullptr, |
| &m_vkSwapChain)); |
| uint32_t imageCount = 0; |
| VK_CHECK(m_vk.vkGetSwapchainImagesKHR(m_vkDevice, m_vkSwapChain, |
| &imageCount, nullptr)); |
| m_vkImages.resize(imageCount); |
| VK_CHECK(m_vk.vkGetSwapchainImagesKHR(m_vkDevice, m_vkSwapChain, |
| &imageCount, m_vkImages.data())); |
| for (auto i = 0; i < m_vkImages.size(); i++) { |
| VkImageViewCreateInfo imageViewCi = { |
| .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, |
| .image = m_vkImages[i], |
| .viewType = VK_IMAGE_VIEW_TYPE_2D, |
| .format = k_vkFormat, |
| .components = {.r = VK_COMPONENT_SWIZZLE_IDENTITY, |
| .g = VK_COMPONENT_SWIZZLE_IDENTITY, |
| .b = VK_COMPONENT_SWIZZLE_IDENTITY, |
| .a = VK_COMPONENT_SWIZZLE_IDENTITY}, |
| .subresourceRange = {.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, |
| .baseMipLevel = 0, |
| .levelCount = 1, |
| .baseArrayLayer = 0, |
| .layerCount = 1}}; |
| VkImageView vkImageView; |
| VK_CHECK(m_vk.vkCreateImageView(m_vkDevice, &imageViewCi, nullptr, |
| &vkImageView)); |
| m_vkImageViews.push_back(vkImageView); |
| } |
| } |
| |
| SwapChainStateVk::~SwapChainStateVk() { |
| for (auto imageView : m_vkImageViews) { |
| m_vk.vkDestroyImageView(m_vkDevice, imageView, nullptr); |
| } |
| m_vk.vkDestroySwapchainKHR(m_vkDevice, m_vkSwapChain, nullptr); |
| } |
| |
| std::vector<const char *> SwapChainStateVk::getRequiredInstanceExtensions() { |
| return { |
| VK_KHR_SURFACE_EXTENSION_NAME, |
| #ifdef _WIN32 |
| VK_KHR_WIN32_SURFACE_EXTENSION_NAME, |
| #endif |
| #ifdef __APPLE__ |
| VK_EXT_METAL_SURFACE_EXTENSION_NAME, |
| #endif |
| #ifdef VK_USE_PLATFORM_XCB_KHR |
| VK_KHR_XCB_SURFACE_EXTENSION_NAME, |
| #endif |
| }; |
| } |
| |
| std::vector<const char *> SwapChainStateVk::getRequiredDeviceExtensions() { |
| return { |
| VK_KHR_SWAPCHAIN_EXTENSION_NAME, |
| }; |
| } |
| |
| bool SwapChainStateVk::validateQueueFamilyProperties( |
| const goldfish_vk::VulkanDispatch &vk, VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, uint32_t queueFamilyIndex) { |
| VkBool32 presentSupport = VK_FALSE; |
| VK_CHECK(vk.vkGetPhysicalDeviceSurfaceSupportKHR( |
| physicalDevice, queueFamilyIndex, surface, &presentSupport)); |
| return presentSupport; |
| } |
| |
| SwapChainStateVk::VkSwapchainCreateInfoKHRPtr |
| SwapChainStateVk::createSwapChainCi( |
| const goldfish_vk::VulkanDispatch &vk, VkSurfaceKHR surface, |
| VkPhysicalDevice physicalDevice, uint32_t width, uint32_t height, |
| const std::unordered_set<uint32_t> &queueFamilyIndices) { |
| uint32_t formatCount = 0; |
| VK_CHECK(vk.vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, |
| &formatCount, nullptr)); |
| std::vector<VkSurfaceFormatKHR> formats(formatCount); |
| VK_CHECK(vk.vkGetPhysicalDeviceSurfaceFormatsKHR( |
| physicalDevice, surface, &formatCount, formats.data())); |
| auto iSurfaceFormat = std::find_if( |
| formats.begin(), formats.end(), [](const VkSurfaceFormatKHR &format) { |
| return format.format == k_vkFormat && |
| format.colorSpace == k_vkColorSpace; |
| }); |
| if (iSurfaceFormat == formats.end()) { |
| SWAPCHAINSTATE_VK_ERROR("Fail to create swapchain: the format(%#" PRIx64 |
| ") with color space(%#" PRIx64 |
| ") not supported.", |
| static_cast<uint64_t>(k_vkFormat), |
| static_cast<uint64_t>(k_vkColorSpace)); |
| return nullptr; |
| } |
| |
| uint32_t presentModeCount = 0; |
| VK_CHECK(vk.vkGetPhysicalDeviceSurfacePresentModesKHR( |
| physicalDevice, surface, &presentModeCount, nullptr)); |
| std::vector<VkPresentModeKHR> presentModes(presentModeCount); |
| VK_CHECK(vk.vkGetPhysicalDeviceSurfacePresentModesKHR( |
| physicalDevice, surface, &presentModeCount, presentModes.data())); |
| auto iPresentMode = |
| std::find_if(presentModes.begin(), presentModes.end(), |
| [](const VkPresentModeKHR &presentMode) { |
| return presentMode == VK_PRESENT_MODE_IMMEDIATE_KHR; |
| }); |
| if (iPresentMode == presentModes.end()) { |
| SWAPCHAINSTATE_VK_ERROR( |
| "Fail to create swapchain: immediate present mode not supported."); |
| return nullptr; |
| } |
| VkSurfaceCapabilitiesKHR surfaceCaps; |
| VK_CHECK(vk.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( |
| physicalDevice, surface, &surfaceCaps)); |
| std::optional<VkExtent2D> maybeExtent = std::nullopt; |
| if (surfaceCaps.currentExtent.width != UINT32_MAX && |
| surfaceCaps.currentExtent.width == width && |
| surfaceCaps.currentExtent.height == height) { |
| maybeExtent = surfaceCaps.currentExtent; |
| } else if (width >= surfaceCaps.minImageExtent.width && |
| width <= surfaceCaps.maxImageExtent.width && |
| height >= surfaceCaps.minImageExtent.height && |
| height <= surfaceCaps.maxImageExtent.height) { |
| maybeExtent = VkExtent2D({width, height}); |
| } |
| if (!maybeExtent.has_value()) { |
| SWAPCHAINSTATE_VK_ERROR("Fail to create swapchain: extent(%" PRIu64 |
| "x%" PRIu64 ") not supported.", |
| static_cast<uint64_t>(width), |
| static_cast<uint64_t>(height)); |
| return nullptr; |
| } |
| auto extent = maybeExtent.value(); |
| uint32_t imageCount = surfaceCaps.minImageCount + 1; |
| if (surfaceCaps.maxImageCount != 0 && |
| surfaceCaps.maxImageCount < imageCount) { |
| imageCount = surfaceCaps.maxImageCount; |
| } |
| VkSwapchainCreateInfoKHRPtr swapChainCi( |
| new VkSwapchainCreateInfoKHR{ |
| .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, |
| .surface = surface, |
| .minImageCount = imageCount, |
| .imageFormat = iSurfaceFormat->format, |
| .imageColorSpace = iSurfaceFormat->colorSpace, |
| .imageExtent = extent, |
| .imageArrayLayers = 1, |
| .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, |
| .preTransform = surfaceCaps.currentTransform, |
| .compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, |
| .presentMode = *iPresentMode, |
| .clipped = VK_TRUE, |
| .oldSwapchain = VK_NULL_HANDLE}, |
| [](VkSwapchainCreateInfoKHR *p) { |
| if (p->pQueueFamilyIndices != nullptr) { |
| delete[] p->pQueueFamilyIndices; |
| } |
| }); |
| if (queueFamilyIndices.empty()) { |
| SWAPCHAINSTATE_VK_ERROR( |
| "Fail to create swapchain: no Vulkan queue family specified."); |
| return nullptr; |
| } |
| if (queueFamilyIndices.size() == 1) { |
| swapChainCi->imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; |
| swapChainCi->queueFamilyIndexCount = 0; |
| swapChainCi->pQueueFamilyIndices = nullptr; |
| } else { |
| swapChainCi->imageSharingMode = VK_SHARING_MODE_CONCURRENT; |
| swapChainCi->queueFamilyIndexCount = |
| static_cast<uint32_t>(queueFamilyIndices.size()); |
| uint32_t *pQueueFamilyIndices = new uint32_t[queueFamilyIndices.size()]; |
| std::copy(queueFamilyIndices.begin(), queueFamilyIndices.end(), |
| pQueueFamilyIndices); |
| swapChainCi->pQueueFamilyIndices = pQueueFamilyIndices; |
| } |
| return swapChainCi; |
| } |
| |
| VkFormat SwapChainStateVk::getFormat() { return k_vkFormat; } |
| |
| const std::vector<VkImage> &SwapChainStateVk::getVkImages() const { |
| return m_vkImages; |
| } |
| |
| const std::vector<VkImageView> &SwapChainStateVk::getVkImageViews() const { |
| return m_vkImageViews; |
| } |
| |
| VkSwapchainKHR SwapChainStateVk::getSwapChain() const { return m_vkSwapChain; } |
