3cc3176ad6
Vulkan for whatever reason does not return VK_ERROR_OUT_OF_DATE_KHR when the swapchain is the wrong size. Explicity make sure the size is indeed up to date to workaround this.
351 lines
15 KiB
C++
351 lines
15 KiB
C++
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cstring>
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <fmt/format.h>
|
|
|
|
#include "common/logging/log.h"
|
|
#include "common/scope_exit.h"
|
|
#include "common/settings.h"
|
|
#include "common/telemetry.h"
|
|
#include "core/core_timing.h"
|
|
#include "core/frontend/emu_window.h"
|
|
#include "core/telemetry_session.h"
|
|
#include "video_core/gpu.h"
|
|
#include "video_core/renderer_vulkan/renderer_vulkan.h"
|
|
#include "video_core/renderer_vulkan/vk_blit_screen.h"
|
|
#include "video_core/renderer_vulkan/vk_rasterizer.h"
|
|
#include "video_core/renderer_vulkan/vk_scheduler.h"
|
|
#include "video_core/renderer_vulkan/vk_state_tracker.h"
|
|
#include "video_core/renderer_vulkan/vk_swapchain.h"
|
|
#include "video_core/vulkan_common/vulkan_debug_callback.h"
|
|
#include "video_core/vulkan_common/vulkan_device.h"
|
|
#include "video_core/vulkan_common/vulkan_instance.h"
|
|
#include "video_core/vulkan_common/vulkan_library.h"
|
|
#include "video_core/vulkan_common/vulkan_memory_allocator.h"
|
|
#include "video_core/vulkan_common/vulkan_surface.h"
|
|
#include "video_core/vulkan_common/vulkan_wrapper.h"
|
|
|
|
namespace Vulkan {
|
|
namespace {
|
|
std::string GetReadableVersion(u32 version) {
|
|
return fmt::format("{}.{}.{}", VK_VERSION_MAJOR(version), VK_VERSION_MINOR(version),
|
|
VK_VERSION_PATCH(version));
|
|
}
|
|
|
|
std::string GetDriverVersion(const Device& device) {
|
|
// Extracted from
|
|
// https://github.com/SaschaWillems/vulkan.gpuinfo.org/blob/5dddea46ea1120b0df14eef8f15ff8e318e35462/functions.php#L308-L314
|
|
const u32 version = device.GetDriverVersion();
|
|
|
|
if (device.GetDriverID() == VK_DRIVER_ID_NVIDIA_PROPRIETARY) {
|
|
const u32 major = (version >> 22) & 0x3ff;
|
|
const u32 minor = (version >> 14) & 0x0ff;
|
|
const u32 secondary = (version >> 6) & 0x0ff;
|
|
const u32 tertiary = version & 0x003f;
|
|
return fmt::format("{}.{}.{}.{}", major, minor, secondary, tertiary);
|
|
}
|
|
if (device.GetDriverID() == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS) {
|
|
const u32 major = version >> 14;
|
|
const u32 minor = version & 0x3fff;
|
|
return fmt::format("{}.{}", major, minor);
|
|
}
|
|
return GetReadableVersion(version);
|
|
}
|
|
|
|
std::string BuildCommaSeparatedExtensions(std::vector<std::string> available_extensions) {
|
|
std::sort(std::begin(available_extensions), std::end(available_extensions));
|
|
|
|
static constexpr std::size_t AverageExtensionSize = 64;
|
|
std::string separated_extensions;
|
|
separated_extensions.reserve(available_extensions.size() * AverageExtensionSize);
|
|
|
|
const auto end = std::end(available_extensions);
|
|
for (auto extension = std::begin(available_extensions); extension != end; ++extension) {
|
|
if (const bool is_last = extension + 1 == end; is_last) {
|
|
separated_extensions += *extension;
|
|
} else {
|
|
separated_extensions += fmt::format("{},", *extension);
|
|
}
|
|
}
|
|
return separated_extensions;
|
|
}
|
|
|
|
Device CreateDevice(const vk::Instance& instance, const vk::InstanceDispatch& dld,
|
|
VkSurfaceKHR surface) {
|
|
const std::vector<VkPhysicalDevice> devices = instance.EnumeratePhysicalDevices();
|
|
const s32 device_index = Settings::values.vulkan_device.GetValue();
|
|
if (device_index < 0 || device_index >= static_cast<s32>(devices.size())) {
|
|
LOG_ERROR(Render_Vulkan, "Invalid device index {}!", device_index);
|
|
throw vk::Exception(VK_ERROR_INITIALIZATION_FAILED);
|
|
}
|
|
const vk::PhysicalDevice physical_device(devices[device_index], dld);
|
|
return Device(*instance, physical_device, surface, dld);
|
|
}
|
|
} // Anonymous namespace
|
|
|
|
RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
|
|
Core::Frontend::EmuWindow& emu_window,
|
|
Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu_,
|
|
std::unique_ptr<Core::Frontend::GraphicsContext> context_) try
|
|
: RendererBase(emu_window, std::move(context_)), telemetry_session(telemetry_session_),
|
|
cpu_memory(cpu_memory_), gpu(gpu_), library(OpenLibrary()),
|
|
instance(CreateInstance(library, dld, VK_API_VERSION_1_1, render_window.GetWindowInfo().type,
|
|
true, Settings::values.renderer_debug.GetValue())),
|
|
debug_callback(Settings::values.renderer_debug ? CreateDebugCallback(instance) : nullptr),
|
|
surface(CreateSurface(instance, render_window)),
|
|
device(CreateDevice(instance, dld, *surface)), memory_allocator(device, false),
|
|
state_tracker(), scheduler(device, state_tracker),
|
|
swapchain(*surface, device, scheduler, render_window.GetFramebufferLayout().width,
|
|
render_window.GetFramebufferLayout().height, false),
|
|
blit_screen(cpu_memory, render_window, device, memory_allocator, swapchain, scheduler,
|
|
screen_info),
|
|
rasterizer(render_window, gpu, cpu_memory, screen_info, device, memory_allocator,
|
|
state_tracker, scheduler) {
|
|
Report();
|
|
} catch (const vk::Exception& exception) {
|
|
LOG_ERROR(Render_Vulkan, "Vulkan initialization failed with error: {}", exception.what());
|
|
throw std::runtime_error{fmt::format("Vulkan initialization error {}", exception.what())};
|
|
}
|
|
|
|
RendererVulkan::~RendererVulkan() {
|
|
void(device.GetLogical().WaitIdle());
|
|
}
|
|
|
|
void RendererVulkan::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
|
|
if (!framebuffer) {
|
|
return;
|
|
}
|
|
SCOPE_EXIT({ render_window.OnFrameDisplayed(); });
|
|
if (!render_window.IsShown()) {
|
|
return;
|
|
}
|
|
// Update screen info if the framebuffer size has changed.
|
|
if (screen_info.width != framebuffer->width || screen_info.height != framebuffer->height) {
|
|
screen_info.width = framebuffer->width;
|
|
screen_info.height = framebuffer->height;
|
|
}
|
|
const VAddr framebuffer_addr = framebuffer->address + framebuffer->offset;
|
|
const bool use_accelerated =
|
|
rasterizer.AccelerateDisplay(*framebuffer, framebuffer_addr, framebuffer->stride);
|
|
const bool is_srgb = use_accelerated && screen_info.is_srgb;
|
|
RenderScreenshot(*framebuffer, use_accelerated);
|
|
|
|
bool has_been_recreated = false;
|
|
const auto recreate_swapchain = [&](u32 width, u32 height) {
|
|
if (!has_been_recreated) {
|
|
has_been_recreated = true;
|
|
scheduler.Finish();
|
|
}
|
|
swapchain.Create(width, height, is_srgb);
|
|
};
|
|
|
|
const Layout::FramebufferLayout layout = render_window.GetFramebufferLayout();
|
|
if (swapchain.NeedsRecreation(is_srgb) || swapchain.GetWidth() != layout.width ||
|
|
swapchain.GetHeight() != layout.height) {
|
|
recreate_swapchain(layout.width, layout.height);
|
|
}
|
|
bool is_outdated;
|
|
do {
|
|
swapchain.AcquireNextImage();
|
|
is_outdated = swapchain.IsOutDated();
|
|
if (is_outdated) {
|
|
recreate_swapchain(layout.width, layout.height);
|
|
}
|
|
} while (is_outdated);
|
|
if (has_been_recreated) {
|
|
blit_screen.Recreate();
|
|
}
|
|
const VkSemaphore render_semaphore = blit_screen.DrawToSwapchain(*framebuffer, use_accelerated);
|
|
const VkSemaphore present_semaphore = swapchain.CurrentPresentSemaphore();
|
|
scheduler.Flush(render_semaphore, present_semaphore);
|
|
scheduler.WaitWorker();
|
|
swapchain.Present(render_semaphore);
|
|
|
|
gpu.RendererFrameEndNotify();
|
|
rasterizer.TickFrame();
|
|
}
|
|
|
|
void RendererVulkan::Report() const {
|
|
using namespace Common::Literals;
|
|
const std::string vendor_name{device.GetVendorName()};
|
|
const std::string model_name{device.GetModelName()};
|
|
const std::string driver_version = GetDriverVersion(device);
|
|
const std::string driver_name = fmt::format("{} {}", vendor_name, driver_version);
|
|
|
|
const std::string api_version = GetReadableVersion(device.ApiVersion());
|
|
|
|
const std::string extensions = BuildCommaSeparatedExtensions(device.GetAvailableExtensions());
|
|
|
|
const auto available_vram = static_cast<f64>(device.GetDeviceLocalMemory()) / f64{1_GiB};
|
|
|
|
LOG_INFO(Render_Vulkan, "Driver: {}", driver_name);
|
|
LOG_INFO(Render_Vulkan, "Device: {}", model_name);
|
|
LOG_INFO(Render_Vulkan, "Vulkan: {}", api_version);
|
|
LOG_INFO(Render_Vulkan, "Available VRAM: {:.2f} GiB", available_vram);
|
|
|
|
static constexpr auto field = Common::Telemetry::FieldType::UserSystem;
|
|
telemetry_session.AddField(field, "GPU_Vendor", vendor_name);
|
|
telemetry_session.AddField(field, "GPU_Model", model_name);
|
|
telemetry_session.AddField(field, "GPU_Vulkan_Driver", driver_name);
|
|
telemetry_session.AddField(field, "GPU_Vulkan_Version", api_version);
|
|
telemetry_session.AddField(field, "GPU_Vulkan_Extensions", extensions);
|
|
}
|
|
|
|
void Vulkan::RendererVulkan::RenderScreenshot(const Tegra::FramebufferConfig& framebuffer,
|
|
bool use_accelerated) {
|
|
if (!renderer_settings.screenshot_requested) {
|
|
return;
|
|
}
|
|
const Layout::FramebufferLayout layout{renderer_settings.screenshot_framebuffer_layout};
|
|
vk::Image staging_image = device.GetLogical().CreateImage(VkImageCreateInfo{
|
|
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
|
|
.pNext = nullptr,
|
|
.flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
|
|
.imageType = VK_IMAGE_TYPE_2D,
|
|
.format = VK_FORMAT_B8G8R8A8_UNORM,
|
|
.extent =
|
|
{
|
|
.width = layout.width,
|
|
.height = layout.height,
|
|
.depth = 1,
|
|
},
|
|
.mipLevels = 1,
|
|
.arrayLayers = 1,
|
|
.samples = VK_SAMPLE_COUNT_1_BIT,
|
|
.tiling = VK_IMAGE_TILING_OPTIMAL,
|
|
.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
|
|
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
|
|
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
|
|
.queueFamilyIndexCount = 0,
|
|
.pQueueFamilyIndices = nullptr,
|
|
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
|
|
});
|
|
const auto image_commit = memory_allocator.Commit(staging_image, MemoryUsage::DeviceLocal);
|
|
|
|
const vk::ImageView dst_view = device.GetLogical().CreateImageView(VkImageViewCreateInfo{
|
|
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
|
|
.pNext = nullptr,
|
|
.flags = 0,
|
|
.image = *staging_image,
|
|
.viewType = VK_IMAGE_VIEW_TYPE_2D,
|
|
.format = screen_info.is_srgb ? VK_FORMAT_B8G8R8A8_SRGB : VK_FORMAT_B8G8R8A8_UNORM,
|
|
.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 = VK_REMAINING_ARRAY_LAYERS,
|
|
},
|
|
});
|
|
const VkExtent2D render_area{.width = layout.width, .height = layout.height};
|
|
const vk::Framebuffer screenshot_fb = blit_screen.CreateFramebuffer(*dst_view, render_area);
|
|
// Since we're not rendering to the screen, ignore the render semaphore.
|
|
void(blit_screen.Draw(framebuffer, *screenshot_fb, layout, render_area, use_accelerated));
|
|
|
|
const auto buffer_size = static_cast<VkDeviceSize>(layout.width * layout.height * 4);
|
|
const VkBufferCreateInfo dst_buffer_info{
|
|
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
|
|
.pNext = nullptr,
|
|
.flags = 0,
|
|
.size = buffer_size,
|
|
.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
|
|
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
|
|
.queueFamilyIndexCount = 0,
|
|
.pQueueFamilyIndices = nullptr,
|
|
};
|
|
const vk::Buffer dst_buffer = device.GetLogical().CreateBuffer(dst_buffer_info);
|
|
MemoryCommit dst_buffer_memory = memory_allocator.Commit(dst_buffer, MemoryUsage::Download);
|
|
|
|
scheduler.RequestOutsideRenderPassOperationContext();
|
|
scheduler.Record([&](vk::CommandBuffer cmdbuf) {
|
|
const VkImageMemoryBarrier read_barrier{
|
|
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
|
|
.pNext = nullptr,
|
|
.srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT,
|
|
.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
|
|
.oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
|
|
.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
|
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
|
.image = *staging_image,
|
|
.subresourceRange{
|
|
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
|
|
.baseMipLevel = 0,
|
|
.levelCount = VK_REMAINING_MIP_LEVELS,
|
|
.baseArrayLayer = 0,
|
|
.layerCount = VK_REMAINING_ARRAY_LAYERS,
|
|
},
|
|
};
|
|
const VkImageMemoryBarrier image_write_barrier{
|
|
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
|
|
.pNext = nullptr,
|
|
.srcAccessMask = 0,
|
|
.dstAccessMask = VK_ACCESS_MEMORY_WRITE_BIT,
|
|
.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
.newLayout = VK_IMAGE_LAYOUT_GENERAL,
|
|
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
|
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
|
.image = *staging_image,
|
|
.subresourceRange{
|
|
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
|
|
.baseMipLevel = 0,
|
|
.levelCount = VK_REMAINING_MIP_LEVELS,
|
|
.baseArrayLayer = 0,
|
|
.layerCount = VK_REMAINING_ARRAY_LAYERS,
|
|
},
|
|
};
|
|
static constexpr VkMemoryBarrier memory_write_barrier{
|
|
.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
|
|
.pNext = nullptr,
|
|
.srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT,
|
|
.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
|
|
};
|
|
const VkBufferImageCopy copy{
|
|
.bufferOffset = 0,
|
|
.bufferRowLength = 0,
|
|
.bufferImageHeight = 0,
|
|
.imageSubresource{
|
|
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
|
|
.mipLevel = 0,
|
|
.baseArrayLayer = 0,
|
|
.layerCount = 1,
|
|
},
|
|
.imageOffset{.x = 0, .y = 0, .z = 0},
|
|
.imageExtent{
|
|
.width = layout.width,
|
|
.height = layout.height,
|
|
.depth = 1,
|
|
},
|
|
};
|
|
cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
|
|
0, read_barrier);
|
|
cmdbuf.CopyImageToBuffer(*staging_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *dst_buffer,
|
|
copy);
|
|
cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
|
|
0, memory_write_barrier, nullptr, image_write_barrier);
|
|
});
|
|
// Ensure the copy is fully completed before saving the screenshot
|
|
scheduler.Finish();
|
|
|
|
// Copy backing image data to the QImage screenshot buffer
|
|
const auto dst_memory_map = dst_buffer_memory.Map();
|
|
std::memcpy(renderer_settings.screenshot_bits, dst_memory_map.data(), dst_memory_map.size());
|
|
renderer_settings.screenshot_complete_callback(false);
|
|
renderer_settings.screenshot_requested = false;
|
|
}
|
|
|
|
} // namespace Vulkan
|