From 6cb1222b9a797efba122eaa050178e4a6228edec Mon Sep 17 00:00:00 2001 From: squidbus <175574877+squidbus@users.noreply.github.com> Date: Wed, 25 Sep 2024 02:05:33 -0700 Subject: [PATCH] vulkan: Use structured bindings for result where possible. --- src/video_core/buffer_cache/buffer.cpp | 10 ++-- .../renderer_vulkan/renderer_vulkan.cpp | 17 +++--- src/video_core/renderer_vulkan/vk_common.h | 2 + .../renderer_vulkan/vk_compute_pipeline.cpp | 24 ++++---- .../renderer_vulkan/vk_graphics_pipeline.cpp | 27 +++++---- .../renderer_vulkan/vk_instance.cpp | 43 +++++++------ .../renderer_vulkan/vk_master_semaphore.cpp | 18 +++--- .../renderer_vulkan/vk_pipeline_cache.cpp | 8 +-- .../renderer_vulkan/vk_platform.cpp | 43 +++++++------ .../renderer_vulkan/vk_resource_pool.cpp | 16 ++--- .../renderer_vulkan/vk_shader_util.cpp | 8 +-- .../renderer_vulkan/vk_swapchain.cpp | 60 +++++++++---------- src/video_core/texture_cache/image_view.cpp | 8 +-- src/video_core/texture_cache/sampler.cpp | 8 +-- src/video_core/texture_cache/tile_manager.cpp | 17 +++--- 15 files changed, 155 insertions(+), 154 deletions(-) diff --git a/src/video_core/buffer_cache/buffer.cpp b/src/video_core/buffer_cache/buffer.cpp index 7476f8034..9fc972248 100644 --- a/src/video_core/buffer_cache/buffer.cpp +++ b/src/video_core/buffer_cache/buffer.cpp @@ -128,12 +128,12 @@ vk::BufferView Buffer::View(u32 offset, u32 size, bool is_written, AmdGpu::DataF .offset = offset, .range = size, }; - const auto view = instance->GetDevice().createBufferView(view_ci); - ASSERT_MSG(view.result == vk::Result::eSuccess, "Failed to create buffer view: {}", - vk::to_string(view.result)); + const auto [view_result, view] = instance->GetDevice().createBufferView(view_ci); + ASSERT_MSG(view_result == vk::Result::eSuccess, "Failed to create buffer view: {}", + vk::to_string(view_result)); scheduler->DeferOperation( - [view, device = instance->GetDevice()] { device.destroyBufferView(view.value); }); - return view.value; + [view, device = instance->GetDevice()] { device.destroyBufferView(view); }); + return view; } constexpr u64 WATCHES_INITIAL_RESERVE = 0x4000; diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.cpp b/src/video_core/renderer_vulkan/renderer_vulkan.cpp index 3385239fb..13bd082d0 100644 --- a/src/video_core/renderer_vulkan/renderer_vulkan.cpp +++ b/src/video_core/renderer_vulkan/renderer_vulkan.cpp @@ -82,10 +82,11 @@ RendererVulkan::RendererVulkan(Frontend::WindowSDL& window_, AmdGpu::Liverpool* present_frames.resize(num_images); for (u32 i = 0; i < num_images; i++) { Frame& frame = present_frames[i]; - auto fence_result = device.createFence({.flags = vk::FenceCreateFlagBits::eSignaled}); - ASSERT_MSG(fence_result.result == vk::Result::eSuccess, - "Failed to create present done fence: {}", vk::to_string(fence_result.result)); - frame.present_done = fence_result.value; + auto [fence_result, fence] = + device.createFence({.flags = vk::FenceCreateFlagBits::eSignaled}); + ASSERT_MSG(fence_result == vk::Result::eSuccess, "Failed to create present done fence: {}", + vk::to_string(fence_result)); + frame.present_done = fence; free_queue.push(&frame); } @@ -160,10 +161,10 @@ void RendererVulkan::RecreateFrame(Frame* frame, u32 width, u32 height) { .layerCount = 1, }, }; - auto view_result = device.createImageView(view_info); - ASSERT_MSG(view_result.result == vk::Result::eSuccess, "Failed to create frame image view: {}", - vk::to_string(view_result.result)); - frame->image_view = view_result.value; + auto [view_result, view] = device.createImageView(view_info); + ASSERT_MSG(view_result == vk::Result::eSuccess, "Failed to create frame image view: {}", + vk::to_string(view_result)); + frame->image_view = view; frame->width = width; frame->height = height; } diff --git a/src/video_core/renderer_vulkan/vk_common.h b/src/video_core/renderer_vulkan/vk_common.h index e23de78e0..e59eb47eb 100644 --- a/src/video_core/renderer_vulkan/vk_common.h +++ b/src/video_core/renderer_vulkan/vk_common.h @@ -15,6 +15,8 @@ #define VULKAN_HPP_NO_STRUCT_SETTERS #define VULKAN_HPP_HAS_SPACESHIP_OPERATOR #define VULKAN_HPP_NO_EXCEPTIONS +// Define assert-on-result to nothing to instead return the result for our handling. +#define VULKAN_HPP_ASSERT_ON_RESULT #include #define VMA_STATIC_VULKAN_FUNCTIONS 0 diff --git a/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp b/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp index 62501e754..cbce85cc1 100644 --- a/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp +++ b/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp @@ -78,12 +78,12 @@ ComputePipeline::ComputePipeline(const Instance& instance_, Scheduler& scheduler .bindingCount = static_cast(bindings.size()), .pBindings = bindings.data(), }; - auto descriptor_set_result = + auto [descriptor_set_result, descriptor_set] = instance.GetDevice().createDescriptorSetLayoutUnique(desc_layout_ci); - ASSERT_MSG(descriptor_set_result.result == vk::Result::eSuccess, + ASSERT_MSG(descriptor_set_result == vk::Result::eSuccess, "Failed to create compute descriptor set layout: {}", - vk::to_string(descriptor_set_result.result)); - desc_layout = std::move(descriptor_set_result.value); + vk::to_string(descriptor_set_result)); + desc_layout = std::move(descriptor_set); const vk::DescriptorSetLayout set_layout = *desc_layout; const vk::PipelineLayoutCreateInfo layout_info = { @@ -92,20 +92,20 @@ ComputePipeline::ComputePipeline(const Instance& instance_, Scheduler& scheduler .pushConstantRangeCount = 1U, .pPushConstantRanges = &push_constants, }; - auto layout_result = instance.GetDevice().createPipelineLayoutUnique(layout_info); - ASSERT_MSG(layout_result.result == vk::Result::eSuccess, - "Failed to create compute pipeline layout: {}", vk::to_string(layout_result.result)); - pipeline_layout = std::move(layout_result.value); + auto [layout_result, layout] = instance.GetDevice().createPipelineLayoutUnique(layout_info); + ASSERT_MSG(layout_result == vk::Result::eSuccess, + "Failed to create compute pipeline layout: {}", vk::to_string(layout_result)); + pipeline_layout = std::move(layout); const vk::ComputePipelineCreateInfo compute_pipeline_ci = { .stage = shader_ci, .layout = *pipeline_layout, }; - auto pipeline_result = + auto [pipeline_result, pipe] = instance.GetDevice().createComputePipelineUnique(pipeline_cache, compute_pipeline_ci); - ASSERT_MSG(pipeline_result.result == vk::Result::eSuccess, - "Failed to create compute pipeline: {}", vk::to_string(pipeline_result.result)); - pipeline = std::move(pipeline_result.value); + ASSERT_MSG(pipeline_result == vk::Result::eSuccess, "Failed to create compute pipeline: {}", + vk::to_string(pipeline_result)); + pipeline = std::move(pipe); } ComputePipeline::~ComputePipeline() = default; diff --git a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp index 56fd3baef..3c191c4a1 100644 --- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp +++ b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp @@ -39,11 +39,10 @@ GraphicsPipeline::GraphicsPipeline(const Instance& instance_, Scheduler& schedul .pushConstantRangeCount = 1, .pPushConstantRanges = &push_constants, }; - auto layout_result = instance.GetDevice().createPipelineLayoutUnique(layout_info); - ASSERT_MSG(layout_result.result == vk::Result::eSuccess, - "Failed to create graphics pipeline layout: {}", - vk::to_string(layout_result.result)); - pipeline_layout = std::move(layout_result.value); + auto [layout_result, layout] = instance.GetDevice().createPipelineLayoutUnique(layout_info); + ASSERT_MSG(layout_result == vk::Result::eSuccess, + "Failed to create graphics pipeline layout: {}", vk::to_string(layout_result)); + pipeline_layout = std::move(layout); boost::container::static_vector vertex_bindings; boost::container::static_vector vertex_attributes; @@ -285,10 +284,11 @@ GraphicsPipeline::GraphicsPipeline(const Instance& instance_, Scheduler& schedul .layout = *pipeline_layout, }; - auto pipeline_result = device.createGraphicsPipelineUnique(pipeline_cache, pipeline_info); - ASSERT_MSG(pipeline_result.result == vk::Result::eSuccess, - "Failed to create graphics pipeline: {}", vk::to_string(pipeline_result.result)); - pipeline = std::move(pipeline_result.value); + auto [pipeline_result, pipe] = + device.createGraphicsPipelineUnique(pipeline_cache, pipeline_info); + ASSERT_MSG(pipeline_result == vk::Result::eSuccess, "Failed to create graphics pipeline: {}", + vk::to_string(pipeline_result)); + pipeline = std::move(pipe); } GraphicsPipeline::~GraphicsPipeline() = default; @@ -347,10 +347,11 @@ void GraphicsPipeline::BuildDescSetLayout() { .bindingCount = static_cast(bindings.size()), .pBindings = bindings.data(), }; - auto result = instance.GetDevice().createDescriptorSetLayoutUnique(desc_layout_ci); - ASSERT_MSG(result.result == vk::Result::eSuccess, - "Failed to create graphics descriptor set layout: {}", vk::to_string(result.result)); - desc_layout = std::move(result.value); + auto [layout_result, layout] = + instance.GetDevice().createDescriptorSetLayoutUnique(desc_layout_ci); + ASSERT_MSG(layout_result == vk::Result::eSuccess, + "Failed to create graphics descriptor set layout: {}", vk::to_string(layout_result)); + desc_layout = std::move(layout); } void GraphicsPipeline::BindResources(const Liverpool::Regs& regs, diff --git a/src/video_core/renderer_vulkan/vk_instance.cpp b/src/video_core/renderer_vulkan/vk_instance.cpp index 730a3b014..76d7aea56 100644 --- a/src/video_core/renderer_vulkan/vk_instance.cpp +++ b/src/video_core/renderer_vulkan/vk_instance.cpp @@ -24,22 +24,22 @@ namespace Vulkan { namespace { std::vector EnumeratePhysicalDevices(vk::UniqueInstance& instance) { - auto devices_result = instance->enumeratePhysicalDevices(); - ASSERT_MSG(devices_result.result == vk::Result::eSuccess, - "Failed to enumerate physical devices: {}", vk::to_string(devices_result.result)); - return std::move(devices_result.value); + auto [devices_result, devices] = instance->enumeratePhysicalDevices(); + ASSERT_MSG(devices_result == vk::Result::eSuccess, "Failed to enumerate physical devices: {}", + vk::to_string(devices_result)); + return std::move(devices); } std::vector GetSupportedExtensions(vk::PhysicalDevice physical) { - const auto extensions = physical.enumerateDeviceExtensionProperties(); - if (extensions.result != vk::Result::eSuccess) { + const auto [extensions_result, extensions] = physical.enumerateDeviceExtensionProperties(); + if (extensions_result != vk::Result::eSuccess) { LOG_ERROR(Render_Vulkan, "Could not query supported extensions: {}", - vk::to_string(extensions.result)); + vk::to_string(extensions_result)); return {}; } std::vector supported_extensions; - supported_extensions.reserve(extensions.value.size()); - for (const auto& extension : extensions.value) { + supported_extensions.reserve(extensions.size()); + for (const auto& extension : extensions) { supported_extensions.emplace_back(extension.extensionName.data()); } return supported_extensions; @@ -433,13 +433,12 @@ bool Instance::CreateDevice() { device_chain.unlink(); } - auto device_result = physical_device.createDeviceUnique(device_chain.get()); - if (device_result.result != vk::Result::eSuccess) { - LOG_CRITICAL(Render_Vulkan, "Failed to create device: {}", - vk::to_string(device_result.result)); + auto [device_result, dev] = physical_device.createDeviceUnique(device_chain.get()); + if (device_result != vk::Result::eSuccess) { + LOG_CRITICAL(Render_Vulkan, "Failed to create device: {}", vk::to_string(device_result)); return false; } - device = std::move(device_result.value); + device = std::move(dev); VULKAN_HPP_DEFAULT_DISPATCHER.init(*device); @@ -447,9 +446,9 @@ bool Instance::CreateDevice() { present_queue = device->getQueue(queue_family_index, 0); if (calibrated_timestamps) { - const auto& time_domains_result = physical_device.getCalibrateableTimeDomainsEXT(); - if (time_domains_result.result == vk::Result::eSuccess) { - const auto& time_domains = time_domains_result.value; + const auto [time_domains_result, time_domains] = + physical_device.getCalibrateableTimeDomainsEXT(); + if (time_domains_result == vk::Result::eSuccess) { #if _WIN64 const bool has_host_time_domain = std::find(time_domains.cbegin(), time_domains.cend(), @@ -473,7 +472,7 @@ bool Instance::CreateDevice() { } } else { LOG_WARNING(Render_Vulkan, "Could not query calibrated time domains for profiling: {}", - vk::to_string(time_domains_result.result)); + vk::to_string(time_domains_result)); } } @@ -529,13 +528,13 @@ void Instance::CollectToolingInfo() { if (!tooling_info) { return; } - const auto tools = physical_device.getToolPropertiesEXT(); - if (tools.result != vk::Result::eSuccess) { + const auto [tools_result, tools] = physical_device.getToolPropertiesEXT(); + if (tools_result != vk::Result::eSuccess) { LOG_ERROR(Render_Vulkan, "Could not get Vulkan tool properties: {}", - vk::to_string(tools.result)); + vk::to_string(tools_result)); return; } - for (const vk::PhysicalDeviceToolProperties& tool : tools.value) { + for (const vk::PhysicalDeviceToolProperties& tool : tools) { const std::string_view name = tool.name; LOG_INFO(Render_Vulkan, "Attached debugging tool: {}", name); has_renderdoc = has_renderdoc || name == "RenderDoc"; diff --git a/src/video_core/renderer_vulkan/vk_master_semaphore.cpp b/src/video_core/renderer_vulkan/vk_master_semaphore.cpp index 0787d8ff2..00f63681e 100644 --- a/src/video_core/renderer_vulkan/vk_master_semaphore.cpp +++ b/src/video_core/renderer_vulkan/vk_master_semaphore.cpp @@ -19,10 +19,11 @@ MasterSemaphore::MasterSemaphore(const Instance& instance_) : instance{instance_ .initialValue = 0, }, }; - auto result = instance.GetDevice().createSemaphoreUnique(semaphore_chain.get()); - ASSERT_MSG(result.result == vk::Result::eSuccess, "Failed to create master semaphore: {}", - vk::to_string(result.result)); - semaphore = std::move(result.value); + auto [semaphore_result, sem] = + instance.GetDevice().createSemaphoreUnique(semaphore_chain.get()); + ASSERT_MSG(semaphore_result == vk::Result::eSuccess, "Failed to create master semaphore: {}", + vk::to_string(semaphore_result)); + semaphore = std::move(sem); } MasterSemaphore::~MasterSemaphore() = default; @@ -32,11 +33,10 @@ void MasterSemaphore::Refresh() { u64 counter{}; do { this_tick = gpu_tick.load(std::memory_order_acquire); - auto counter_result = instance.GetDevice().getSemaphoreCounterValue(*semaphore); - ASSERT_MSG(counter_result.result == vk::Result::eSuccess, - "Failed to get master semaphore value: {}", - vk::to_string(counter_result.result)); - counter = counter_result.value; + auto [counter_result, cntr] = instance.GetDevice().getSemaphoreCounterValue(*semaphore); + ASSERT_MSG(counter_result == vk::Result::eSuccess, + "Failed to get master semaphore value: {}", vk::to_string(counter_result)); + counter = cntr; if (counter < this_tick) { return; } diff --git a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp index 5857feab8..4aca00730 100644 --- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp +++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp @@ -136,10 +136,10 @@ PipelineCache::PipelineCache(const Instance& instance_, Scheduler& scheduler_, .subgroup_size = instance.SubgroupSize(), .support_explicit_workgroup_layout = true, }; - auto cache_result = instance.GetDevice().createPipelineCacheUnique({}); - ASSERT_MSG(cache_result.result == vk::Result::eSuccess, "Failed to create pipeline cache: {}", - vk::to_string(cache_result.result)); - pipeline_cache = std::move(cache_result.value); + auto [cache_result, cache] = instance.GetDevice().createPipelineCacheUnique({}); + ASSERT_MSG(cache_result == vk::Result::eSuccess, "Failed to create pipeline cache: {}", + vk::to_string(cache_result)); + pipeline_cache = std::move(cache); } PipelineCache::~PipelineCache() = default; diff --git a/src/video_core/renderer_vulkan/vk_platform.cpp b/src/video_core/renderer_vulkan/vk_platform.cpp index fde1335f9..0eb7e0759 100644 --- a/src/video_core/renderer_vulkan/vk_platform.cpp +++ b/src/video_core/renderer_vulkan/vk_platform.cpp @@ -134,13 +134,12 @@ vk::SurfaceKHR CreateSurface(vk::Instance instance, const Frontend::WindowSDL& e std::vector GetInstanceExtensions(Frontend::WindowSystemType window_type, bool enable_debug_utils) { - const auto properties_result = vk::enumerateInstanceExtensionProperties(); - if (properties_result.result != vk::Result::eSuccess || properties_result.value.empty()) { + const auto [properties_result, properties] = vk::enumerateInstanceExtensionProperties(); + if (properties_result != vk::Result::eSuccess || properties.empty()) { LOG_ERROR(Render_Vulkan, "Failed to query extension properties: {}", - vk::to_string(properties_result.result)); + vk::to_string(properties_result)); return {}; } - const auto& properties = properties_result.value; // Add the windowing system specific extension std::vector extensions; @@ -209,16 +208,16 @@ vk::UniqueInstance CreateInstance(Frontend::WindowSystemType window_type, bool e #endif VULKAN_HPP_DEFAULT_DISPATCHER.init(vkGetInstanceProcAddr); - const auto available_version = VULKAN_HPP_DEFAULT_DISPATCHER.vkEnumerateInstanceVersion - ? vk::enumerateInstanceVersion() - : vk::ResultValue(vk::Result::eSuccess, VK_API_VERSION_1_0); - ASSERT_MSG(available_version.result == vk::Result::eSuccess, - "Failed to query Vulkan API version: {}", vk::to_string(available_version.result)); - ASSERT_MSG(available_version.value >= TargetVulkanApiVersion, + const auto [available_version_result, available_version] = + VULKAN_HPP_DEFAULT_DISPATCHER.vkEnumerateInstanceVersion + ? vk::enumerateInstanceVersion() + : vk::ResultValue(vk::Result::eSuccess, VK_API_VERSION_1_0); + ASSERT_MSG(available_version_result == vk::Result::eSuccess, + "Failed to query Vulkan API version: {}", vk::to_string(available_version_result)); + ASSERT_MSG(available_version >= TargetVulkanApiVersion, "Vulkan {}.{} is required, but only {}.{} is supported by instance!", VK_VERSION_MAJOR(TargetVulkanApiVersion), VK_VERSION_MINOR(TargetVulkanApiVersion), - VK_VERSION_MAJOR(available_version.value), - VK_VERSION_MINOR(available_version.value)); + VK_VERSION_MAJOR(available_version), VK_VERSION_MINOR(available_version)); const auto extensions = GetInstanceExtensions(window_type, true); @@ -227,7 +226,7 @@ vk::UniqueInstance CreateInstance(Frontend::WindowSystemType window_type, bool e .applicationVersion = VK_MAKE_VERSION(1, 0, 0), .pEngineName = "shadPS4 Vulkan", .engineVersion = VK_MAKE_VERSION(1, 0, 0), - .apiVersion = available_version.value, + .apiVersion = available_version, }; u32 num_layers = 0; @@ -345,13 +344,13 @@ vk::UniqueInstance CreateInstance(Frontend::WindowSystemType window_type, bool e }, }; - auto instance_result = vk::createInstanceUnique(instance_ci_chain.get()); - ASSERT_MSG(instance_result.result == vk::Result::eSuccess, "Failed to create instance: {}", - vk::to_string(instance_result.result)); + auto [instance_result, instance] = vk::createInstanceUnique(instance_ci_chain.get()); + ASSERT_MSG(instance_result == vk::Result::eSuccess, "Failed to create instance: {}", + vk::to_string(instance_result)); - VULKAN_HPP_DEFAULT_DISPATCHER.init(*instance_result.value); + VULKAN_HPP_DEFAULT_DISPATCHER.init(*instance); - return std::move(instance_result.value); + return std::move(instance); } vk::UniqueDebugUtilsMessengerEXT CreateDebugCallback(vk::Instance instance) { @@ -365,10 +364,10 @@ vk::UniqueDebugUtilsMessengerEXT CreateDebugCallback(vk::Instance instance) { vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance, .pfnUserCallback = DebugUtilsCallback, }; - auto result = instance.createDebugUtilsMessengerEXTUnique(msg_ci); - ASSERT_MSG(result.result == vk::Result::eSuccess, "Failed to create debug callback: {}", - vk::to_string(result.result)); - return std::move(result.value); + auto [messenger_result, messenger] = instance.createDebugUtilsMessengerEXTUnique(msg_ci); + ASSERT_MSG(messenger_result == vk::Result::eSuccess, "Failed to create debug callback: {}", + vk::to_string(messenger_result)); + return std::move(messenger); } } // namespace Vulkan diff --git a/src/video_core/renderer_vulkan/vk_resource_pool.cpp b/src/video_core/renderer_vulkan/vk_resource_pool.cpp index ab6f405d1..25a134528 100644 --- a/src/video_core/renderer_vulkan/vk_resource_pool.cpp +++ b/src/video_core/renderer_vulkan/vk_resource_pool.cpp @@ -69,10 +69,10 @@ CommandPool::CommandPool(const Instance& instance, MasterSemaphore* master_semap .queueFamilyIndex = instance.GetGraphicsQueueFamilyIndex(), }; const vk::Device device = instance.GetDevice(); - auto result = device.createCommandPoolUnique(pool_create_info); - ASSERT_MSG(result.result == vk::Result::eSuccess, "Failed to create command pool: {}", - vk::to_string(result.result)); - cmd_pool = std::move(result.value); + auto [pool_result, pool] = device.createCommandPoolUnique(pool_create_info); + ASSERT_MSG(pool_result == vk::Result::eSuccess, "Failed to create command pool: {}", + vk::to_string(pool_result)); + cmd_pool = std::move(pool); if (instance.HasDebuggingToolAttached()) { SetObjectName(device, *cmd_pool, "CommandPool"); } @@ -185,10 +185,10 @@ void DescriptorHeap::CreateDescriptorPool() { .poolSizeCount = static_cast(pool_sizes.size()), .pPoolSizes = pool_sizes.data(), }; - auto result = device.createDescriptorPool(pool_info); - ASSERT_MSG(result.result == vk::Result::eSuccess, "Failed to create descriptor pool: {}", - vk::to_string(result.result)); - curr_pool = result.value; + auto [pool_result, pool] = device.createDescriptorPool(pool_info); + ASSERT_MSG(pool_result == vk::Result::eSuccess, "Failed to create descriptor pool: {}", + vk::to_string(pool_result)); + curr_pool = pool; } } // namespace Vulkan diff --git a/src/video_core/renderer_vulkan/vk_shader_util.cpp b/src/video_core/renderer_vulkan/vk_shader_util.cpp index 998501405..f9347d6e6 100644 --- a/src/video_core/renderer_vulkan/vk_shader_util.cpp +++ b/src/video_core/renderer_vulkan/vk_shader_util.cpp @@ -218,10 +218,10 @@ vk::ShaderModule CompileSPV(std::span code, vk::Device device) { .pCode = code.data(), }; - auto result = device.createShaderModule(shader_info); - ASSERT_MSG(result.result == vk::Result::eSuccess, "Failed to compile SPIR-V shader: {}", - vk::to_string(result.result)); - return result.value; + auto [module_result, module] = device.createShaderModule(shader_info); + ASSERT_MSG(module_result == vk::Result::eSuccess, "Failed to compile SPIR-V shader: {}", + vk::to_string(module_result)); + return module; } } // namespace Vulkan diff --git a/src/video_core/renderer_vulkan/vk_swapchain.cpp b/src/video_core/renderer_vulkan/vk_swapchain.cpp index 9360d69cd..142ef4f5c 100644 --- a/src/video_core/renderer_vulkan/vk_swapchain.cpp +++ b/src/video_core/renderer_vulkan/vk_swapchain.cpp @@ -37,16 +37,17 @@ void Swapchain::Create(u32 width_, u32 height_, vk::SurfaceKHR surface_) { instance.GetPresentQueueFamilyIndex(), }; - const auto modes = instance.GetPhysicalDevice().getSurfacePresentModesKHR(surface); - const auto find_mode = [&modes](vk::PresentModeKHR requested) { - if (modes.result != vk::Result::eSuccess) { + const auto [modes_result, modes] = + instance.GetPhysicalDevice().getSurfacePresentModesKHR(surface); + const auto find_mode = [&modes_result, &modes](vk::PresentModeKHR requested) { + if (modes_result != vk::Result::eSuccess) { return false; } const auto it = - std::find_if(modes.value.begin(), modes.value.end(), + std::find_if(modes.begin(), modes.end(), [&requested](vk::PresentModeKHR mode) { return mode == requested; }); - return it != modes.value.end(); + return it != modes.end(); }; const bool has_mailbox = find_mode(vk::PresentModeKHR::eMailbox); @@ -73,10 +74,10 @@ void Swapchain::Create(u32 width_, u32 height_, vk::SurfaceKHR surface_) { .oldSwapchain = nullptr, }; - auto swapchain_result = instance.GetDevice().createSwapchainKHR(swapchain_info); - ASSERT_MSG(swapchain_result.result == vk::Result::eSuccess, "Failed to create swapchain: {}", - vk::to_string(swapchain_result.result)); - swapchain = std::move(swapchain_result.value); + auto [swapchain_result, chain] = instance.GetDevice().createSwapchainKHR(swapchain_info); + ASSERT_MSG(swapchain_result == vk::Result::eSuccess, "Failed to create swapchain: {}", + vk::to_string(swapchain_result)); + swapchain = chain; SetupImages(); RefreshSemaphores(); @@ -132,10 +133,10 @@ void Swapchain::Present() { } void Swapchain::FindPresentFormat() { - const auto formats_result = instance.GetPhysicalDevice().getSurfaceFormatsKHR(surface); - ASSERT_MSG(formats_result.result == vk::Result::eSuccess, "Failed to query surface formats: {}", - vk::to_string(formats_result.result)); - const auto& formats = formats_result.value; + const auto [formats_result, formats] = + instance.GetPhysicalDevice().getSurfaceFormatsKHR(surface); + ASSERT_MSG(formats_result == vk::Result::eSuccess, "Failed to query surface formats: {}", + vk::to_string(formats_result)); // If there is a single undefined surface format, the device doesn't care, so we'll just use // RGBA sRGB. @@ -161,12 +162,10 @@ void Swapchain::FindPresentFormat() { } void Swapchain::SetSurfaceProperties() { - const auto capabilities_result = + const auto [capabilities_result, capabilities] = instance.GetPhysicalDevice().getSurfaceCapabilitiesKHR(surface); - ASSERT_MSG(capabilities_result.result == vk::Result::eSuccess, - "Failed to query surface capabilities: {}", - vk::to_string(capabilities_result.result)); - const auto& capabilities = capabilities_result.value; + ASSERT_MSG(capabilities_result == vk::Result::eSuccess, + "Failed to query surface capabilities: {}", vk::to_string(capabilities_result)); extent = capabilities.currentExtent; if (capabilities.currentExtent.width == std::numeric_limits::max()) { @@ -214,16 +213,17 @@ void Swapchain::RefreshSemaphores() { present_ready.resize(image_count); for (vk::Semaphore& semaphore : image_acquired) { - auto result = device.createSemaphore({}); - ASSERT_MSG(result.result == vk::Result::eSuccess, - "Failed to create image acquired semaphore: {}", vk::to_string(result.result)); - semaphore = result.value; + auto [semaphore_result, sem] = device.createSemaphore({}); + ASSERT_MSG(semaphore_result == vk::Result::eSuccess, + "Failed to create image acquired semaphore: {}", + vk::to_string(semaphore_result)); + semaphore = sem; } for (vk::Semaphore& semaphore : present_ready) { - auto result = device.createSemaphore({}); - ASSERT_MSG(result.result == vk::Result::eSuccess, - "Failed to create present ready semaphore: {}", vk::to_string(result.result)); - semaphore = result.value; + auto [semaphore_result, sem] = device.createSemaphore({}); + ASSERT_MSG(semaphore_result == vk::Result::eSuccess, + "Failed to create present ready semaphore: {}", vk::to_string(semaphore_result)); + semaphore = sem; } if (instance.HasDebuggingToolAttached()) { @@ -236,10 +236,10 @@ void Swapchain::RefreshSemaphores() { void Swapchain::SetupImages() { vk::Device device = instance.GetDevice(); - auto images_result = device.getSwapchainImagesKHR(swapchain); - ASSERT_MSG(images_result.result == vk::Result::eSuccess, - "Failed to create swapchain images: {}", vk::to_string(images_result.result)); - images = std::move(images_result.value); + auto [images_result, imgs] = device.getSwapchainImagesKHR(swapchain); + ASSERT_MSG(images_result == vk::Result::eSuccess, "Failed to create swapchain images: {}", + vk::to_string(images_result)); + images = std::move(imgs); image_count = static_cast(images.size()); if (instance.HasDebuggingToolAttached()) { diff --git a/src/video_core/texture_cache/image_view.cpp b/src/video_core/texture_cache/image_view.cpp index 36dafe415..db8113499 100644 --- a/src/video_core/texture_cache/image_view.cpp +++ b/src/video_core/texture_cache/image_view.cpp @@ -175,10 +175,10 @@ ImageView::ImageView(const Vulkan::Instance& instance, const ImageViewInfo& info .layerCount = info.range.extent.layers, }, }; - auto result = instance.GetDevice().createImageViewUnique(image_view_ci); - ASSERT_MSG(result.result == vk::Result::eSuccess, "Failed to create image view: {}", - vk::to_string(result.result)); - image_view = std::move(result.value); + auto [view_result, view] = instance.GetDevice().createImageViewUnique(image_view_ci); + ASSERT_MSG(view_result == vk::Result::eSuccess, "Failed to create image view: {}", + vk::to_string(view_result)); + image_view = std::move(view); } ImageView::~ImageView() = default; diff --git a/src/video_core/texture_cache/sampler.cpp b/src/video_core/texture_cache/sampler.cpp index 72cb727a2..ed567b9ee 100644 --- a/src/video_core/texture_cache/sampler.cpp +++ b/src/video_core/texture_cache/sampler.cpp @@ -24,10 +24,10 @@ Sampler::Sampler(const Vulkan::Instance& instance, const AmdGpu::Sampler& sample .borderColor = LiverpoolToVK::BorderColor(sampler.border_color_type), .unnormalizedCoordinates = bool(sampler.force_unnormalized), }; - auto result = instance.GetDevice().createSamplerUnique(sampler_ci); - ASSERT_MSG(result.result == vk::Result::eSuccess, "Failed to create sampler: {}", - vk::to_string(result.result)); - handle = std::move(result.value); + auto [sampler_result, smplr] = instance.GetDevice().createSamplerUnique(sampler_ci); + ASSERT_MSG(sampler_result == vk::Result::eSuccess, "Failed to create sampler: {}", + vk::to_string(sampler_result)); + handle = std::move(smplr); } Sampler::~Sampler() = default; diff --git a/src/video_core/texture_cache/tile_manager.cpp b/src/video_core/texture_cache/tile_manager.cpp index 7f9b078b2..429afcae6 100644 --- a/src/video_core/texture_cache/tile_manager.cpp +++ b/src/video_core/texture_cache/tile_manager.cpp @@ -298,11 +298,10 @@ TileManager::TileManager(const Vulkan::Instance& instance, Vulkan::Scheduler& sc .bindingCount = static_cast(bindings.size()), .pBindings = bindings.data(), }; - static auto desc_layout_result = + static auto [desc_layout_result, desc_layout] = instance.GetDevice().createDescriptorSetLayoutUnique(desc_layout_ci); - ASSERT_MSG(desc_layout_result.result == vk::Result::eSuccess, - "Failed to create descriptor set layout: {}", - vk::to_string(desc_layout_result.result)); + ASSERT_MSG(desc_layout_result == vk::Result::eSuccess, + "Failed to create descriptor set layout: {}", vk::to_string(desc_layout_result)); const vk::PushConstantRange push_constants = { .stageFlags = vk::ShaderStageFlagBits::eCompute, @@ -310,17 +309,17 @@ TileManager::TileManager(const Vulkan::Instance& instance, Vulkan::Scheduler& sc .size = sizeof(DetilerParams), }; - const vk::DescriptorSetLayout set_layout = *desc_layout_result.value; + const vk::DescriptorSetLayout set_layout = *desc_layout; const vk::PipelineLayoutCreateInfo layout_info = { .setLayoutCount = 1U, .pSetLayouts = &set_layout, .pushConstantRangeCount = 1, .pPushConstantRanges = &push_constants, }; - auto layout_result = instance.GetDevice().createPipelineLayoutUnique(layout_info); - ASSERT_MSG(layout_result.result == vk::Result::eSuccess, - "Failed to create pipeline layout: {}", vk::to_string(layout_result.result)); - ctx.pl_layout = std::move(layout_result.value); + auto [layout_result, layout] = instance.GetDevice().createPipelineLayoutUnique(layout_info); + ASSERT_MSG(layout_result == vk::Result::eSuccess, "Failed to create pipeline layout: {}", + vk::to_string(layout_result)); + ctx.pl_layout = std::move(layout); const vk::ComputePipelineCreateInfo compute_pipeline_ci = { .stage = shader_ci,