Linuxydable/suyu
1
0
Fork 0
forked from suyu/suyu
Code Pull requests Activity
suyu/src/video_core/renderer_vulkan/renderer_vulkan.cpp

187 lines
7.8 KiB
C++
Raw Normal View History

yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
// Copyright 2018 yuzu Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
yuzu: Drop SDL2 and Qt frontend Vulkan requirements Create Vulkan instances and surfaces from the Vulkan backend.
2020-04-02 07:32:58 +02:00
#include <algorithm>
#include <array>
#include <cstring>
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
#include <memory>
#include <optional>
yuzu: Drop SDL2 and Qt frontend Vulkan requirements Create Vulkan instances and surfaces from the Vulkan backend.
2020-04-02 07:32:58 +02:00
#include <string>
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
#include <vector>
#include <fmt/format.h>
#include "common/logging/log.h"
common: Move settings to common from core. - Removes a dependency on core and input_common from common.
2021-04-15 01:07:40 +02:00
#include "common/settings.h"
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
#include "common/telemetry.h"
#include "core/core.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"
renderer_vulkan: Make unconditional use of VK_KHR_timeline_semaphore This reworks how host<->device synchronization works on the Vulkan backend. Instead of "protecting" resources with a fence and signalling these as free when the fence is known to be signalled by the host GPU, use timeline semaphores. Vulkan timeline semaphores allow use to work on a subset of D3D12 fences. As far as we are concerned, timeline semaphores are a value set by the host or the device that can be waited by either of them. Taking advantange of this, we can have a monolithically increasing atomic value for each submission to the graphics queue. Instead of protecting resources with a fence, we simply store the current logical tick (the atomic value stored in CPU memory). When we want to know if a resource is free, it can be compared to the current GPU tick. This greatly simplifies resource management code and the free status of resources should have less false negatives. To workaround bugs in validation layers, when these are attached there's a thread waiting for timeline semaphores.
2020-09-10 08:43:30 +02:00
#include "video_core/renderer_vulkan/vk_master_semaphore.h"
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
#include "video_core/renderer_vulkan/vk_rasterizer.h"
#include "video_core/renderer_vulkan/vk_scheduler.h"
vk_state_tracker: Initial implementation Add support for render targets and viewports.
2020-02-21 00:35:53 +01:00
#include "video_core/renderer_vulkan/vk_state_tracker.h"
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
#include "video_core/renderer_vulkan/vk_swapchain.h"
renderer_vulkan: Create debug callback on separate file and throw Initialize debug callbacks (messenger) from a separate file. This allows sharing code with different backends. Change our Vulkan error handling to use exceptions instead of error codes, simplifying the initialization process.
2020-12-25 06:01:13 +01:00
#include "video_core/vulkan_common/vulkan_debug_callback.h"
renderer_vulkan: Move device abstraction to vulkan_common
2020-12-26 05:19:46 +01:00
#include "video_core/vulkan_common/vulkan_device.h"
renderer_vulkan: Move instance initialization to a separate file Simplify Vulkan's backend initialization code by moving it to a separate file, allowing us to initialize a Vulkan instance from different backends.
2020-12-25 02:05:48 +01:00
#include "video_core/vulkan_common/vulkan_instance.h"
vulkan_common: Move dynamic library load to a separate file Allows us to initialize a Vulkan dynamic library from different backends without duplicating code.
2020-12-25 01:24:34 +01:00
#include "video_core/vulkan_common/vulkan_library.h"
vulkan_common: Move allocator to the common directory Allow using the abstraction from the OpenGL backend.
2021-01-03 22:17:57 +01:00
#include "video_core/vulkan_common/vulkan_memory_allocator.h"
renderer_vulkan: Initialize surface in separate file Move surface initialization code to a separate file. It's unlikely to use this code outside of Vulkan, but keeping platform-specific code (Win32, Xlib, Wayland) in its own translation unit keeps things cleaner.
2020-12-25 06:14:15 +01:00
#include "video_core/vulkan_common/vulkan_surface.h"
vulkan_common: Rename renderer_vulkan/wrapper.h to vulkan_common/vulkan_wrapper.h Allows sharing Vulkan wrapper code between different rendering backends.
2020-12-25 01:30:11 +01:00
#include "video_core/vulkan_common/vulkan_wrapper.h"
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
namespace Vulkan {
namespace {
std::string GetReadableVersion(u32 version) {
return fmt::format("{}.{}.{}", VK_VERSION_MAJOR(version), VK_VERSION_MINOR(version),
VK_VERSION_PATCH(version));
}
renderer_vulkan: Rename VKDevice to Device The "VK" prefix predates the "Vulkan" namespace. It was carried around the codebase for consistency. "VKDevice" currently is a bad alias with "VkDevice" (only an upcase character of difference) that can cause confusion. Rename all instances of it.
2020-12-26 05:10:53 +01:00
std::string GetDriverVersion(const Device& device) {
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
// Extracted from
// https://github.com/SaschaWillems/vulkan.gpuinfo.org/blob/5dddea46ea1120b0df14eef8f15ff8e318e35462/functions.php#L308-L314
const u32 version = device.GetDriverVersion();
renderer_vulkan: Drop Vulkan-Hpp
2020-03-27 05:33:21 +01:00
if (device.GetDriverID() == VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR) {
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
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);
}
renderer_vulkan: Drop Vulkan-Hpp
2020-03-27 05:33:21 +01:00
if (device.GetDriverID() == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR) {
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
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;
}
gpu: Report renderer errors with exceptions Instead of using a two step initialization to report errors, initialize the GPU renderer and rasterizer on the constructor and report errors through std::runtime_error.
2021-01-05 08:09:39 +01:00
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);
}
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
} // Anonymous namespace
video_core: Remove all Core::System references in renderer Now that the GPU is initialized when video backends are initialized, it's no longer needed to query components once the game is running: it can be done when yuzu is booting. This allows us to pass components between constructors and in the process remove all Core::System references in the video backend.
2020-06-12 02:24:45 +02:00
RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
Core::Frontend::EmuWindow& emu_window,
Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu_,
gpu: Report renderer errors with exceptions Instead of using a two step initialization to report errors, initialize the GPU renderer and rasterizer on the constructor and report errors through std::runtime_error.
2021-01-05 08:09:39 +01:00
std::unique_ptr<Core::Frontend::GraphicsContext> context_) try
yuzu qt: Make most UISettings a BasicSetting For simple primitive settings, moves their defaults and labels to definition time. Also fixes typo and clang-format yuzu qt: config: Fix rng_seed
2021-06-28 23:32:24 +02:00
: RendererBase(emu_window, std::move(context_)),
telemetry_session(telemetry_session_),
cpu_memory(cpu_memory_),
gpu(gpu_),
library(OpenLibrary()),
gpu: Report renderer errors with exceptions Instead of using a two step initialization to report errors, initialize the GPU renderer and rasterizer on the constructor and report errors through std::runtime_error.
2021-01-05 08:09:39 +01:00
instance(CreateInstance(library, dld, VK_API_VERSION_1_1, render_window.GetWindowInfo().type,
general: Make most settings a BasicSetting Creates a new BasicSettings class in common/settings, and forces setting a default and label for each setting that uses it in common/settings. Moves defaults and labels from both frontends into common settings. Creates a helper function in each frontend to facillitate reading the settings now with the new default and label properties. Settings::Setting is also now a subclass of Settings::BasicSetting. Also adds documentation for both Setting and BasicSetting.
2021-06-28 21:58:16 +02:00
true, Settings::values.renderer_debug.GetValue())),
gpu: Report renderer errors with exceptions Instead of using a two step initialization to report errors, initialize the GPU renderer and rasterizer on the constructor and report errors through std::runtime_error.
2021-01-05 08:09:39 +01:00
debug_callback(Settings::values.renderer_debug ? CreateDebugCallback(instance) : nullptr),
surface(CreateSurface(instance, render_window)),
yuzu qt: Make most UISettings a BasicSetting For simple primitive settings, moves their defaults and labels to definition time. Also fixes typo and clang-format yuzu qt: config: Fix rng_seed
2021-06-28 23:32:24 +02:00
device(CreateDevice(instance, dld, *surface)),
memory_allocator(device, false),
state_tracker(gpu),
scheduler(device, state_tracker),
gpu: Report renderer errors with exceptions Instead of using a two step initialization to report errors, initialize the GPU renderer and rasterizer on the constructor and report errors through std::runtime_error.
2021-01-05 08:09:39 +01:00
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, gpu.MemoryManager(), 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())};
}
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
RendererVulkan::~RendererVulkan() {
gpu: Report renderer errors with exceptions Instead of using a two step initialization to report errors, initialize the GPU renderer and rasterizer on the constructor and report errors through std::runtime_error.
2021-01-05 08:09:39 +01:00
void(device.GetLogical().WaitIdle());
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
}
void RendererVulkan::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
frontend: qt: bootmanager: Vulkan: Restore support for VK backend.
2020-02-18 03:29:12 +01:00
if (!framebuffer) {
return;
}
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
const auto& layout = render_window.GetFramebufferLayout();
frontend: qt: bootmanager: Vulkan: Restore support for VK backend.
2020-02-18 03:29:12 +01:00
if (layout.width > 0 && layout.height > 0 && render_window.IsShown()) {
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
const VAddr framebuffer_addr = framebuffer->address + framebuffer->offset;
const bool use_accelerated =
gpu: Report renderer errors with exceptions Instead of using a two step initialization to report errors, initialize the GPU renderer and rasterizer on the constructor and report errors through std::runtime_error.
2021-01-05 08:09:39 +01:00
rasterizer.AccelerateDisplay(*framebuffer, framebuffer_addr, framebuffer->stride);
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
const bool is_srgb = use_accelerated && screen_info.is_srgb;
gpu: Report renderer errors with exceptions Instead of using a two step initialization to report errors, initialize the GPU renderer and rasterizer on the constructor and report errors through std::runtime_error.
2021-01-05 08:09:39 +01:00
if (swapchain.HasFramebufferChanged(layout) || swapchain.GetSrgbState() != is_srgb) {
swapchain.Create(layout.width, layout.height, is_srgb);
blit_screen.Recreate();
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
}
gpu: Report renderer errors with exceptions Instead of using a two step initialization to report errors, initialize the GPU renderer and rasterizer on the constructor and report errors through std::runtime_error.
2021-01-05 08:09:39 +01:00
scheduler.WaitWorker();
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
renderer_vulkan: Check return value of AcquireNextImage We can get into a really bad state by ignoring this leading to device loss and using incorrect resources.
2021-04-11 09:46:28 +02:00
while (!swapchain.AcquireNextImage()) {
swapchain.Create(layout.width, layout.height, is_srgb);
blit_screen.Recreate();
}
gpu: Report renderer errors with exceptions Instead of using a two step initialization to report errors, initialize the GPU renderer and rasterizer on the constructor and report errors through std::runtime_error.
2021-01-05 08:09:39 +01:00
const VkSemaphore render_semaphore = blit_screen.Draw(*framebuffer, use_accelerated);
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
gpu: Report renderer errors with exceptions Instead of using a two step initialization to report errors, initialize the GPU renderer and rasterizer on the constructor and report errors through std::runtime_error.
2021-01-05 08:09:39 +01:00
scheduler.Flush(render_semaphore);
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
gpu: Report renderer errors with exceptions Instead of using a two step initialization to report errors, initialize the GPU renderer and rasterizer on the constructor and report errors through std::runtime_error.
2021-01-05 08:09:39 +01:00
if (swapchain.Present(render_semaphore)) {
blit_screen.Recreate();
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
}
perf_stats: Rework FPS counter to be more accurate The FPS counter was based on metrics in the nvdisp swapbuffers call. This metric would be accurate if the gpu thread/renderer were synchronous with the nvdisp service, but that's no longer the case. This commit moves the frame counting responsibility onto the concrete renderers after their frame draw calls. Resulting in more meaningful metrics. The displayed FPS is now made up of the average framerate between the previous and most recent update, in order to avoid distracting FPS counter updates when framerate is oscillating between close values. The status bar update frequency was also changed from 2 seconds to 500ms.
2021-05-16 02:34:20 +02:00
gpu.RendererFrameEndNotify();
gpu: Report renderer errors with exceptions Instead of using a two step initialization to report errors, initialize the GPU renderer and rasterizer on the constructor and report errors through std::runtime_error.
2021-01-05 08:09:39 +01:00
rasterizer.TickFrame();
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
}
Overhaul EmuWindow::PollEvents to fix yuzu-cmd calling SDL_PollEvents off main thread EmuWindow::PollEvents was called from the GPU thread (or the CPU thread in sync-GPU mode) when swapping buffers. It had three implementations: - In GRenderWindow, it didn't actually poll events, just set a flag and emit a signal to indicate that a frame was displayed. - In EmuWindow_SDL2_Hide, it did nothing. - In EmuWindow_SDL2, it did call SDL_PollEvents, but this is wrong because SDL_PollEvents is supposed to be called on the thread that set up video - in this case, the main thread, which was sleeping in a busyloop (regardless of whether sync-GPU was enabled). On macOS this causes a crash. To fix this: - Rename EmuWindow::PollEvents to OnFrameDisplayed, and give it a default implementation that does nothing. - In EmuWindow_SDL2, do not override OnFrameDisplayed, but instead have the main thread call SDL_WaitEvent in a loop.
2020-11-22 22:05:18 +01:00
render_window.OnFrameDisplayed();
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
}
void RendererVulkan::Report() const {
gpu: Report renderer errors with exceptions Instead of using a two step initialization to report errors, initialize the GPU renderer and rasterizer on the constructor and report errors through std::runtime_error.
2021-01-05 08:09:39 +01:00
const std::string vendor_name{device.GetVendorName()};
const std::string model_name{device.GetModelName()};
const std::string driver_version = GetDriverVersion(device);
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
const std::string driver_name = fmt::format("{} {}", vendor_name, driver_version);
gpu: Report renderer errors with exceptions Instead of using a two step initialization to report errors, initialize the GPU renderer and rasterizer on the constructor and report errors through std::runtime_error.
2021-01-05 08:09:39 +01:00
const std::string api_version = GetReadableVersion(device.ApiVersion());
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
gpu: Report renderer errors with exceptions Instead of using a two step initialization to report errors, initialize the GPU renderer and rasterizer on the constructor and report errors through std::runtime_error.
2021-01-05 08:09:39 +01:00
const std::string extensions = BuildCommaSeparatedExtensions(device.GetAvailableExtensions());
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
LOG_INFO(Render_Vulkan, "Driver: {}", driver_name);
LOG_INFO(Render_Vulkan, "Device: {}", model_name);
LOG_INFO(Render_Vulkan, "Vulkan: {}", api_version);
video_core: Remove all Core::System references in renderer Now that the GPU is initialized when video backends are initialized, it's no longer needed to query components once the game is running: it can be done when yuzu is booting. This allows us to pass components between constructors and in the process remove all Core::System references in the video backend.
2020-06-12 02:24:45 +02:00
static constexpr auto field = Common::Telemetry::FieldType::UserSystem;
yuzu: Implement Vulkan frontend Adds a Qt and SDL2 frontend for Vulkan. It also finishes the missing bits on Vulkan initialization.
2020-01-21 20:40:53 +01:00
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);
}
frontend: qt: bootmanager: Vulkan: Restore support for VK backend.
2020-02-18 03:29:12 +01:00
} // namespace Vulkan
Copy permalink