mirror of
https://gitea.wildfiregames.com/0ad/0ad
synced 2026-06-16 05:13:58 -07:00
157c6af18e
Avoid cases of filenames Update years in terms and other legal(ish) documents Don't update years in license headers, since change is not meaningful Will add linter rule in seperate commit Happy recompiling everyone! Original Patch By: Nescio Comment By: Gallaecio Differential Revision: D2620 This was SVN commit r27786.
384 lines
14 KiB
C++
384 lines
14 KiB
C++
/* Copyright (C) 2023 Wildfire Games.
|
||
* This file is part of 0 A.D.
|
||
*
|
||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||
* it under the terms of the GNU General Public License as published by
|
||
* the Free Software Foundation, either version 2 of the License, or
|
||
* (at your option) any later version.
|
||
*
|
||
* 0 A.D. is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
* GNU General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU General Public License
|
||
* along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
|
||
*/
|
||
|
||
#include "precompiled.h"
|
||
|
||
#include "SwapChain.h"
|
||
|
||
#include "lib/hash.h"
|
||
#include "maths/MathUtil.h"
|
||
#include "ps/ConfigDB.h"
|
||
#include "ps/Profile.h"
|
||
#include "renderer/backend/vulkan/Device.h"
|
||
#include "renderer/backend/vulkan/Framebuffer.h"
|
||
#include "renderer/backend/vulkan/RingCommandContext.h"
|
||
#include "renderer/backend/vulkan/Texture.h"
|
||
#include "renderer/backend/vulkan/Utilities.h"
|
||
|
||
#include <algorithm>
|
||
#include <limits>
|
||
|
||
namespace Renderer
|
||
{
|
||
|
||
namespace Backend
|
||
{
|
||
|
||
namespace Vulkan
|
||
{
|
||
|
||
// static
|
||
std::unique_ptr<CSwapChain> CSwapChain::Create(
|
||
CDevice* device, VkSurfaceKHR surface, int surfaceDrawableWidth, int surfaceDrawableHeight,
|
||
std::unique_ptr<CSwapChain> oldSwapChain)
|
||
{
|
||
VkPhysicalDevice physicalDevice = device->GetChoosenPhysicalDevice().device;
|
||
|
||
VkSurfaceCapabilitiesKHR surfaceCapabilities{};
|
||
ENSURE_VK_SUCCESS(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
|
||
physicalDevice, surface, &surfaceCapabilities));
|
||
|
||
const uint32_t swapChainWidth = Clamp<uint32_t>(surfaceDrawableWidth,
|
||
surfaceCapabilities.minImageExtent.width,
|
||
surfaceCapabilities.maxImageExtent.width);
|
||
const uint32_t swapChainHeight = Clamp<uint32_t>(surfaceDrawableHeight,
|
||
surfaceCapabilities.minImageExtent.height,
|
||
surfaceCapabilities.maxImageExtent.height);
|
||
|
||
// Some drivers (for example NVIDIA on Windows during minimize) might
|
||
// return zeroes for both minImageExtent and maxImageExtent. It means we're
|
||
// not able to create any swapchain. Because we can't choose zeros (they're
|
||
// not allowed) and we can't choose values bigger than maxImageExtent
|
||
// (which are also zeroes in that case).
|
||
if (swapChainWidth == 0 || swapChainHeight == 0)
|
||
return nullptr;
|
||
|
||
std::vector<VkSurfaceFormatKHR> surfaceFormats;
|
||
uint32_t surfaceFormatCount = 0;
|
||
ENSURE_VK_SUCCESS(vkGetPhysicalDeviceSurfaceFormatsKHR(
|
||
physicalDevice, surface, &surfaceFormatCount, nullptr));
|
||
if (surfaceFormatCount > 0)
|
||
{
|
||
surfaceFormats.resize(surfaceFormatCount);
|
||
ENSURE_VK_SUCCESS(vkGetPhysicalDeviceSurfaceFormatsKHR(
|
||
physicalDevice, surface, &surfaceFormatCount, surfaceFormats.data()));
|
||
}
|
||
|
||
std::vector<VkPresentModeKHR> presentModes;
|
||
uint32_t presentModeCount = 0;
|
||
ENSURE_VK_SUCCESS(vkGetPhysicalDeviceSurfacePresentModesKHR(
|
||
physicalDevice, surface, &presentModeCount, nullptr));
|
||
if (presentModeCount > 0)
|
||
{
|
||
presentModes.resize(presentModeCount);
|
||
ENSURE_VK_SUCCESS(vkGetPhysicalDeviceSurfacePresentModesKHR(
|
||
physicalDevice, surface, &presentModeCount, presentModes.data()));
|
||
}
|
||
|
||
// VK_PRESENT_MODE_FIFO_KHR is guaranteed to be supported.
|
||
VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
|
||
auto isPresentModeAvailable = [&presentModes](const VkPresentModeKHR presentMode)
|
||
{
|
||
return std::find(presentModes.begin(), presentModes.end(), presentMode) != presentModes.end();
|
||
};
|
||
bool vsyncEnabled = true;
|
||
CFG_GET_VAL("vsync", vsyncEnabled);
|
||
if (vsyncEnabled)
|
||
{
|
||
// TODO: use the adaptive one when possible.
|
||
// https://gitlab.freedesktop.org/mesa/mesa/-/issues/5516
|
||
//if (isPresentModeAvailable(VK_PRESENT_MODE_MAILBOX_KHR))
|
||
// presentMode = VK_PRESENT_MODE_MAILBOX_KHR;
|
||
}
|
||
else
|
||
{
|
||
if (isPresentModeAvailable(VK_PRESENT_MODE_IMMEDIATE_KHR))
|
||
presentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
|
||
}
|
||
|
||
// Spec says:
|
||
// The number of format pairs supported must be greater than or equal to 1.
|
||
// pSurfaceFormats must not contain an entry whose value for format is
|
||
// VK_FORMAT_UNDEFINED.
|
||
const auto surfaceFormatIt =
|
||
std::find_if(surfaceFormats.begin(), surfaceFormats.end(), IsSurfaceFormatSupported);
|
||
if (surfaceFormatIt == surfaceFormats.end())
|
||
{
|
||
LOGERROR("Can't find a suitable surface format to render to.");
|
||
return nullptr;
|
||
}
|
||
const VkSurfaceFormatKHR& surfaceFormat = *surfaceFormatIt;
|
||
|
||
VkSwapchainCreateInfoKHR swapChainCreateInfo{};
|
||
swapChainCreateInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
|
||
swapChainCreateInfo.surface = surface;
|
||
// minImageCount + 1 is to have a less chance for a presenter to wait.
|
||
// maxImageCount might be zero, it means it's unlimited.
|
||
const uint32_t maxImageCount = surfaceCapabilities.maxImageCount > 0
|
||
? surfaceCapabilities.maxImageCount
|
||
: std::numeric_limits<uint32_t>::max();
|
||
const uint32_t minImageCount = surfaceCapabilities.minImageCount < maxImageCount
|
||
? surfaceCapabilities.minImageCount + 1
|
||
: surfaceCapabilities.minImageCount;
|
||
swapChainCreateInfo.minImageCount =
|
||
Clamp<uint32_t>(NUMBER_OF_FRAMES_IN_FLIGHT,
|
||
minImageCount, maxImageCount);
|
||
swapChainCreateInfo.imageFormat = surfaceFormat.format;
|
||
swapChainCreateInfo.imageColorSpace = surfaceFormat.colorSpace;
|
||
swapChainCreateInfo.imageExtent.width = swapChainWidth;
|
||
swapChainCreateInfo.imageExtent.height = swapChainHeight;
|
||
swapChainCreateInfo.imageArrayLayers = 1;
|
||
// VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT is guaranteed to present.
|
||
// VK_IMAGE_USAGE_TRANSFER_SRC_BIT allows a simpler backbuffer readback.
|
||
// VK_IMAGE_USAGE_TRANSFER_DST_BIT allows a blit to the backbuffer.
|
||
swapChainCreateInfo.imageUsage =
|
||
(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT) &
|
||
surfaceCapabilities.supportedUsageFlags;
|
||
swapChainCreateInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||
// We need to set these only if imageSharingMode is VK_SHARING_MODE_CONCURRENT.
|
||
swapChainCreateInfo.queueFamilyIndexCount = 0;
|
||
swapChainCreateInfo.pQueueFamilyIndices = nullptr;
|
||
// By default VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR is preferable.
|
||
if (surfaceCapabilities.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR)
|
||
swapChainCreateInfo.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
|
||
else
|
||
swapChainCreateInfo.preTransform = surfaceCapabilities.currentTransform;
|
||
// By default VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR is preferable, other bits
|
||
// might require some format or rendering adjustemnts to avoid
|
||
// semi-transparent areas.
|
||
const VkCompositeAlphaFlagBitsKHR compositeAlphaOrder[] =
|
||
{
|
||
VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
|
||
VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR,
|
||
VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
|
||
VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR
|
||
};
|
||
for (const VkCompositeAlphaFlagBitsKHR compositeAlpha : compositeAlphaOrder)
|
||
if (compositeAlpha & surfaceCapabilities.supportedCompositeAlpha)
|
||
{
|
||
swapChainCreateInfo.compositeAlpha = compositeAlpha;
|
||
break;
|
||
}
|
||
swapChainCreateInfo.presentMode = presentMode;
|
||
swapChainCreateInfo.clipped = VK_TRUE;
|
||
if (oldSwapChain)
|
||
swapChainCreateInfo.oldSwapchain = oldSwapChain->GetVkSwapchain();
|
||
|
||
std::unique_ptr<CSwapChain> swapChain(new CSwapChain());
|
||
swapChain->m_Device = device;
|
||
ENSURE_VK_SUCCESS(vkCreateSwapchainKHR(
|
||
device->GetVkDevice(), &swapChainCreateInfo, nullptr, &swapChain->m_SwapChain));
|
||
|
||
char nameBuffer[64];
|
||
snprintf(nameBuffer, std::size(nameBuffer), "SwapChain: %dx%d", surfaceDrawableWidth, surfaceDrawableHeight);
|
||
device->SetObjectName(VK_OBJECT_TYPE_SWAPCHAIN_KHR, swapChain->m_SwapChain, nameBuffer);
|
||
|
||
uint32_t imageCount = 0;
|
||
ENSURE_VK_SUCCESS(vkGetSwapchainImagesKHR(
|
||
device->GetVkDevice(), swapChain->m_SwapChain, &imageCount, nullptr));
|
||
swapChain->m_Images.resize(imageCount);
|
||
ENSURE_VK_SUCCESS(vkGetSwapchainImagesKHR(
|
||
device->GetVkDevice(), swapChain->m_SwapChain, &imageCount, swapChain->m_Images.data()));
|
||
|
||
swapChain->m_DepthTexture = CTexture::Create(
|
||
device, "SwapChainDepthTexture", ITexture::Type::TEXTURE_2D,
|
||
ITexture::Usage::DEPTH_STENCIL_ATTACHMENT,
|
||
device->GetPreferredDepthStencilFormat(
|
||
Renderer::Backend::ITexture::Usage::DEPTH_STENCIL_ATTACHMENT,
|
||
true, true),
|
||
swapChainWidth, swapChainHeight, Sampler::MakeDefaultSampler(
|
||
Sampler::Filter::NEAREST, Sampler::AddressMode::CLAMP_TO_EDGE),
|
||
1, 1);
|
||
|
||
swapChain->m_ImageFormat = swapChainCreateInfo.imageFormat;
|
||
|
||
swapChain->m_Textures.resize(imageCount);
|
||
swapChain->m_Backbuffers.resize(imageCount);
|
||
for (size_t index = 0; index < imageCount; ++index)
|
||
{
|
||
snprintf(nameBuffer, std::size(nameBuffer), "SwapChainImage #%zu", index);
|
||
device->SetObjectName(VK_OBJECT_TYPE_IMAGE, swapChain->m_Images[index], nameBuffer);
|
||
snprintf(nameBuffer, std::size(nameBuffer), "SwapChainImageView #%zu", index);
|
||
swapChain->m_Textures[index] = CTexture::WrapBackbufferImage(
|
||
device, nameBuffer, swapChain->m_Images[index], swapChainCreateInfo.imageFormat,
|
||
swapChainCreateInfo.imageUsage, swapChainWidth, swapChainHeight);
|
||
}
|
||
|
||
swapChain->m_IsValid = true;
|
||
|
||
return swapChain;
|
||
}
|
||
|
||
CSwapChain::CSwapChain() = default;
|
||
|
||
CSwapChain::~CSwapChain()
|
||
{
|
||
m_Backbuffers.clear();
|
||
|
||
m_Textures.clear();
|
||
m_DepthTexture.reset();
|
||
|
||
if (m_SwapChain != VK_NULL_HANDLE)
|
||
vkDestroySwapchainKHR(m_Device->GetVkDevice(), m_SwapChain, nullptr);
|
||
}
|
||
|
||
size_t CSwapChain::SwapChainBackbuffer::BackbufferKeyHash::operator()(const BackbufferKey& key) const
|
||
{
|
||
size_t seed = 0;
|
||
hash_combine(seed, std::get<0>(key));
|
||
hash_combine(seed, std::get<1>(key));
|
||
hash_combine(seed, std::get<2>(key));
|
||
hash_combine(seed, std::get<3>(key));
|
||
return seed;
|
||
}
|
||
|
||
CSwapChain::SwapChainBackbuffer::SwapChainBackbuffer() = default;
|
||
|
||
CSwapChain::SwapChainBackbuffer::SwapChainBackbuffer(SwapChainBackbuffer&& other) = default;
|
||
|
||
CSwapChain::SwapChainBackbuffer& CSwapChain::SwapChainBackbuffer::operator=(SwapChainBackbuffer&& other) = default;
|
||
|
||
bool CSwapChain::AcquireNextImage(VkSemaphore acquireImageSemaphore)
|
||
{
|
||
ENSURE(m_CurrentImageIndex == std::numeric_limits<uint32_t>::max());
|
||
|
||
const VkResult acquireResult = vkAcquireNextImageKHR(
|
||
m_Device->GetVkDevice(), m_SwapChain, std::numeric_limits<uint64_t>::max(),
|
||
acquireImageSemaphore,
|
||
VK_NULL_HANDLE, &m_CurrentImageIndex);
|
||
if (acquireResult != VK_SUCCESS)
|
||
{
|
||
if (acquireResult == VK_ERROR_OUT_OF_DATE_KHR)
|
||
m_IsValid = false;
|
||
else if (acquireResult != VK_SUBOPTIMAL_KHR)
|
||
{
|
||
LOGERROR("Acquire result: %d", static_cast<int>(acquireResult));
|
||
debug_warn("Unknown acquire error.");
|
||
}
|
||
}
|
||
return m_IsValid;
|
||
}
|
||
|
||
void CSwapChain::SubmitCommandsAfterAcquireNextImage(
|
||
CRingCommandContext& commandContext)
|
||
{
|
||
const bool firstAcquirement = !m_Textures[m_CurrentImageIndex]->IsInitialized();
|
||
Utilities::SubmitImageMemoryBarrier(
|
||
commandContext.GetCommandBuffer(),
|
||
m_Images[m_CurrentImageIndex], 0, 0,
|
||
0, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
|
||
firstAcquirement ? VK_IMAGE_LAYOUT_UNDEFINED : VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
|
||
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
|
||
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
|
||
if (!m_DepthTexture->IsInitialized())
|
||
{
|
||
Utilities::SubmitImageMemoryBarrier(
|
||
commandContext.GetCommandBuffer(),
|
||
m_DepthTexture->GetImage(), 0, 0,
|
||
0, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
|
||
VK_IMAGE_LAYOUT_UNDEFINED,
|
||
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
|
||
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
|
||
VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT);
|
||
}
|
||
}
|
||
|
||
void CSwapChain::SubmitCommandsBeforePresent(
|
||
CRingCommandContext& commandContext)
|
||
{
|
||
ENSURE(m_CurrentImageIndex != std::numeric_limits<uint32_t>::max());
|
||
|
||
Utilities::SubmitImageMemoryBarrier(
|
||
commandContext.GetCommandBuffer(), m_Images[m_CurrentImageIndex], 0, 0,
|
||
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, 0,
|
||
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
|
||
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);
|
||
}
|
||
|
||
void CSwapChain::Present(VkSemaphore submitDone, VkQueue queue)
|
||
{
|
||
ENSURE(m_CurrentImageIndex != std::numeric_limits<uint32_t>::max());
|
||
|
||
VkSwapchainKHR swapChains[] = {m_SwapChain};
|
||
|
||
VkPresentInfoKHR presentInfo{};
|
||
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
|
||
presentInfo.swapchainCount = 1;
|
||
presentInfo.pSwapchains = swapChains;
|
||
presentInfo.pImageIndices = &m_CurrentImageIndex;
|
||
presentInfo.waitSemaphoreCount = 1;
|
||
presentInfo.pWaitSemaphores = &submitDone;
|
||
const VkResult presentResult = vkQueuePresentKHR(queue, &presentInfo);
|
||
if (presentResult != VK_SUCCESS)
|
||
{
|
||
if (presentResult == VK_ERROR_OUT_OF_DATE_KHR)
|
||
m_IsValid = false;
|
||
else if (presentResult != VK_SUBOPTIMAL_KHR)
|
||
{
|
||
LOGERROR("Present result: %d", static_cast<int>(presentResult));
|
||
debug_warn("Unknown present error.");
|
||
}
|
||
}
|
||
|
||
m_CurrentImageIndex = std::numeric_limits<uint32_t>::max();
|
||
}
|
||
|
||
CFramebuffer* CSwapChain::GetCurrentBackbuffer(
|
||
const AttachmentLoadOp colorAttachmentLoadOp,
|
||
const AttachmentStoreOp colorAttachmentStoreOp,
|
||
const AttachmentLoadOp depthStencilAttachmentLoadOp,
|
||
const AttachmentStoreOp depthStencilAttachmentStoreOp)
|
||
{
|
||
ENSURE(m_CurrentImageIndex != std::numeric_limits<uint32_t>::max());
|
||
SwapChainBackbuffer& swapChainBackbuffer =
|
||
m_Backbuffers[m_CurrentImageIndex];
|
||
const SwapChainBackbuffer::BackbufferKey key{
|
||
colorAttachmentLoadOp, colorAttachmentStoreOp,
|
||
depthStencilAttachmentLoadOp, depthStencilAttachmentStoreOp};
|
||
auto it = swapChainBackbuffer.backbuffers.find(key);
|
||
if (it == swapChainBackbuffer.backbuffers.end())
|
||
{
|
||
char nameBuffer[64];
|
||
snprintf(nameBuffer, std::size(nameBuffer), "Backbuffer #%u", m_CurrentImageIndex);
|
||
|
||
SColorAttachment colorAttachment{};
|
||
colorAttachment.texture = m_Textures[m_CurrentImageIndex].get();
|
||
colorAttachment.loadOp = colorAttachmentLoadOp;
|
||
colorAttachment.storeOp = colorAttachmentStoreOp;
|
||
|
||
SDepthStencilAttachment depthStencilAttachment{};
|
||
depthStencilAttachment.texture = m_DepthTexture.get();
|
||
depthStencilAttachment.loadOp = depthStencilAttachmentLoadOp;
|
||
depthStencilAttachment.storeOp = depthStencilAttachmentStoreOp;
|
||
|
||
it = swapChainBackbuffer.backbuffers.emplace(key, CFramebuffer::Create(
|
||
m_Device, nameBuffer, &colorAttachment, &depthStencilAttachment)).first;
|
||
}
|
||
return it->second.get();
|
||
}
|
||
|
||
CTexture* CSwapChain::GetCurrentBackbufferTexture()
|
||
{
|
||
ENSURE(m_CurrentImageIndex != std::numeric_limits<uint32_t>::max());
|
||
return m_Textures[m_CurrentImageIndex].get();
|
||
}
|
||
|
||
} // namespace Vulkan
|
||
|
||
} // namespace Backend
|
||
|
||
} // namespace Renderer
|