summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/common/CMakeLists.txt2
-rw-r--r--src/common/dynamic_library.cpp106
-rw-r--r--src/common/dynamic_library.h75
-rw-r--r--src/core/frontend/emu_window.h41
-rw-r--r--src/core/hle/service/nvflinger/buffer_queue.cpp48
-rw-r--r--src/core/hle/service/nvflinger/buffer_queue.h2
-rw-r--r--src/core/hle/service/vi/vi.cpp46
-rw-r--r--src/video_core/engines/maxwell_3d.h67
-rw-r--r--src/video_core/engines/shader_bytecode.h57
-rw-r--r--src/video_core/renderer_vulkan/declarations.h2
-rw-r--r--src/video_core/renderer_vulkan/renderer_vulkan.cpp264
-rw-r--r--src/video_core/renderer_vulkan/renderer_vulkan.h19
-rw-r--r--src/video_core/renderer_vulkan/vk_device.cpp92
-rw-r--r--src/video_core/renderer_vulkan/vk_device.h21
-rw-r--r--src/video_core/shader/decode/video.cpp58
-rw-r--r--src/video_core/shader/shader_ir.h3
-rw-r--r--src/video_core/textures/texture.h15
-rw-r--r--src/yuzu/CMakeLists.txt4
-rw-r--r--src/yuzu/bootmanager.cpp92
-rw-r--r--src/yuzu/bootmanager.h9
-rw-r--r--src/yuzu/configuration/configure_graphics.cpp42
-rw-r--r--src/yuzu/configuration/configure_input_player.cpp15
-rw-r--r--src/yuzu/configuration/configure_input_simple.cpp9
-rw-r--r--src/yuzu/configuration/configure_mouse_advanced.cpp15
-rw-r--r--src/yuzu/game_list.cpp6
-rw-r--r--src/yuzu/game_list_p.h24
-rw-r--r--src/yuzu_cmd/emu_window/emu_window_sdl2_gl.cpp6
-rw-r--r--src/yuzu_cmd/emu_window/emu_window_sdl2_gl.h4
-rw-r--r--src/yuzu_cmd/emu_window/emu_window_sdl2_vk.cpp159
-rw-r--r--src/yuzu_cmd/emu_window/emu_window_sdl2_vk.h18
-rw-r--r--src/yuzu_tester/emu_window/emu_window_sdl2_hide.cpp4
-rw-r--r--src/yuzu_tester/emu_window/emu_window_sdl2_hide.h4
32 files changed, 937 insertions, 392 deletions
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index fbebed715..eeceaa655 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -106,6 +106,8 @@ add_library(common STATIC
106 common_funcs.h 106 common_funcs.h
107 common_paths.h 107 common_paths.h
108 common_types.h 108 common_types.h
109 dynamic_library.cpp
110 dynamic_library.h
109 file_util.cpp 111 file_util.cpp
110 file_util.h 112 file_util.h
111 hash.h 113 hash.h
diff --git a/src/common/dynamic_library.cpp b/src/common/dynamic_library.cpp
new file mode 100644
index 000000000..7ab54e9e4
--- /dev/null
+++ b/src/common/dynamic_library.cpp
@@ -0,0 +1,106 @@
1// Copyright 2019 Dolphin Emulator Project
2// Licensed under GPLv2+
3// Refer to the license.txt file included.
4
5#include <cstring>
6#include <string>
7#include <utility>
8
9#include <fmt/format.h>
10
11#include "common/dynamic_library.h"
12
13#ifdef _WIN32
14#include <windows.h>
15#else
16#include <dlfcn.h>
17#endif
18
19namespace Common {
20
21DynamicLibrary::DynamicLibrary() = default;
22
23DynamicLibrary::DynamicLibrary(const char* filename) {
24 Open(filename);
25}
26
27DynamicLibrary::DynamicLibrary(DynamicLibrary&& rhs) noexcept
28 : handle{std::exchange(rhs.handle, nullptr)} {}
29
30DynamicLibrary& DynamicLibrary::operator=(DynamicLibrary&& rhs) noexcept {
31 Close();
32 handle = std::exchange(rhs.handle, nullptr);
33 return *this;
34}
35
36DynamicLibrary::~DynamicLibrary() {
37 Close();
38}
39
40std::string DynamicLibrary::GetUnprefixedFilename(const char* filename) {
41#if defined(_WIN32)
42 return std::string(filename) + ".dll";
43#elif defined(__APPLE__)
44 return std::string(filename) + ".dylib";
45#else
46 return std::string(filename) + ".so";
47#endif
48}
49
50std::string DynamicLibrary::GetVersionedFilename(const char* libname, int major, int minor) {
51#if defined(_WIN32)
52 if (major >= 0 && minor >= 0)
53 return fmt::format("{}-{}-{}.dll", libname, major, minor);
54 else if (major >= 0)
55 return fmt::format("{}-{}.dll", libname, major);
56 else
57 return fmt::format("{}.dll", libname);
58#elif defined(__APPLE__)
59 const char* prefix = std::strncmp(libname, "lib", 3) ? "lib" : "";
60 if (major >= 0 && minor >= 0)
61 return fmt::format("{}{}.{}.{}.dylib", prefix, libname, major, minor);
62 else if (major >= 0)
63 return fmt::format("{}{}.{}.dylib", prefix, libname, major);
64 else
65 return fmt::format("{}{}.dylib", prefix, libname);
66#else
67 const char* prefix = std::strncmp(libname, "lib", 3) ? "lib" : "";
68 if (major >= 0 && minor >= 0)
69 return fmt::format("{}{}.so.{}.{}", prefix, libname, major, minor);
70 else if (major >= 0)
71 return fmt::format("{}{}.so.{}", prefix, libname, major);
72 else
73 return fmt::format("{}{}.so", prefix, libname);
74#endif
75}
76
77bool DynamicLibrary::Open(const char* filename) {
78#ifdef _WIN32
79 handle = reinterpret_cast<void*>(LoadLibraryA(filename));
80#else
81 handle = dlopen(filename, RTLD_NOW);
82#endif
83 return handle != nullptr;
84}
85
86void DynamicLibrary::Close() {
87 if (!IsOpen())
88 return;
89
90#ifdef _WIN32
91 FreeLibrary(reinterpret_cast<HMODULE>(handle));
92#else
93 dlclose(handle);
94#endif
95 handle = nullptr;
96}
97
98void* DynamicLibrary::GetSymbolAddress(const char* name) const {
99#ifdef _WIN32
100 return reinterpret_cast<void*>(GetProcAddress(reinterpret_cast<HMODULE>(handle), name));
101#else
102 return reinterpret_cast<void*>(dlsym(handle, name));
103#endif
104}
105
106} // namespace Common
diff --git a/src/common/dynamic_library.h b/src/common/dynamic_library.h
new file mode 100644
index 000000000..2a06372fd
--- /dev/null
+++ b/src/common/dynamic_library.h
@@ -0,0 +1,75 @@
1// Copyright 2019 Dolphin Emulator Project
2// Licensed under GPLv2+
3// Refer to the license.txt file included.
4
5#pragma once
6
7#include <string>
8
9namespace Common {
10
11/**
12 * Provides a platform-independent interface for loading a dynamic library and retrieving symbols.
13 * The interface maintains an internal reference count to allow one handle to be shared between
14 * multiple users.
15 */
16class DynamicLibrary final {
17public:
18 /// Default constructor, does not load a library.
19 explicit DynamicLibrary();
20
21 /// Automatically loads the specified library. Call IsOpen() to check validity before use.
22 explicit DynamicLibrary(const char* filename);
23
24 /// Moves the library.
25 DynamicLibrary(DynamicLibrary&&) noexcept;
26 DynamicLibrary& operator=(DynamicLibrary&&) noexcept;
27
28 /// Delete copies, we can't copy a dynamic library.
29 DynamicLibrary(const DynamicLibrary&) = delete;
30 DynamicLibrary& operator=(const DynamicLibrary&) = delete;
31
32 /// Closes the library.
33 ~DynamicLibrary();
34
35 /// Returns the specified library name with the platform-specific suffix added.
36 static std::string GetUnprefixedFilename(const char* filename);
37
38 /// Returns the specified library name in platform-specific format.
39 /// Major/minor versions will not be included if set to -1.
40 /// If libname already contains the "lib" prefix, it will not be added again.
41 /// Windows: LIBNAME-MAJOR-MINOR.dll
42 /// Linux: libLIBNAME.so.MAJOR.MINOR
43 /// Mac: libLIBNAME.MAJOR.MINOR.dylib
44 static std::string GetVersionedFilename(const char* libname, int major = -1, int minor = -1);
45
46 /// Returns true if a module is loaded, otherwise false.
47 bool IsOpen() const {
48 return handle != nullptr;
49 }
50
51 /// Loads (or replaces) the handle with the specified library file name.
52 /// Returns true if the library was loaded and can be used.
53 bool Open(const char* filename);
54
55 /// Unloads the library, any function pointers from this library are no longer valid.
56 void Close();
57
58 /// Returns the address of the specified symbol (function or variable) as an untyped pointer.
59 /// If the specified symbol does not exist in this library, nullptr is returned.
60 void* GetSymbolAddress(const char* name) const;
61
62 /// Obtains the address of the specified symbol, automatically casting to the correct type.
63 /// Returns true if the symbol was found and assigned, otherwise false.
64 template <typename T>
65 bool GetSymbol(const char* name, T* ptr) const {
66 *ptr = reinterpret_cast<T>(GetSymbolAddress(name));
67 return *ptr != nullptr;
68 }
69
70private:
71 /// Platform-dependent data type representing a dynamic library handle.
72 void* handle = nullptr;
73};
74
75} // namespace Common
diff --git a/src/core/frontend/emu_window.h b/src/core/frontend/emu_window.h
index 72294d4d8..13aa14934 100644
--- a/src/core/frontend/emu_window.h
+++ b/src/core/frontend/emu_window.h
@@ -12,6 +12,15 @@
12 12
13namespace Core::Frontend { 13namespace Core::Frontend {
14 14
15/// Information for the Graphics Backends signifying what type of screen pointer is in
16/// WindowInformation
17enum class WindowSystemType {
18 Headless,
19 Windows,
20 X11,
21 Wayland,
22};
23
15/** 24/**
16 * Represents a drawing context that supports graphics operations. 25 * Represents a drawing context that supports graphics operations.
17 */ 26 */
@@ -76,6 +85,23 @@ public:
76 std::pair<unsigned, unsigned> min_client_area_size; 85 std::pair<unsigned, unsigned> min_client_area_size;
77 }; 86 };
78 87
88 /// Data describing host window system information
89 struct WindowSystemInfo {
90 // Window system type. Determines which GL context or Vulkan WSI is used.
91 WindowSystemType type = WindowSystemType::Headless;
92
93 // Connection to a display server. This is used on X11 and Wayland platforms.
94 void* display_connection = nullptr;
95
96 // Render surface. This is a pointer to the native window handle, which depends
97 // on the platform. e.g. HWND for Windows, Window for X11. If the surface is
98 // set to nullptr, the video backend will run in headless mode.
99 void* render_surface = nullptr;
100
101 // Scale of the render surface. For hidpi systems, this will be >1.
102 float render_surface_scale = 1.0f;
103 };
104
79 /// Polls window events 105 /// Polls window events
80 virtual void PollEvents() = 0; 106 virtual void PollEvents() = 0;
81 107
@@ -87,10 +113,6 @@ public:
87 /// Returns if window is shown (not minimized) 113 /// Returns if window is shown (not minimized)
88 virtual bool IsShown() const = 0; 114 virtual bool IsShown() const = 0;
89 115
90 /// Retrieves Vulkan specific handlers from the window
91 virtual void RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
92 void* surface) const = 0;
93
94 /** 116 /**
95 * Signal that a touch pressed event has occurred (e.g. mouse click pressed) 117 * Signal that a touch pressed event has occurred (e.g. mouse click pressed)
96 * @param framebuffer_x Framebuffer x-coordinate that was pressed 118 * @param framebuffer_x Framebuffer x-coordinate that was pressed
@@ -128,6 +150,13 @@ public:
128 } 150 }
129 151
130 /** 152 /**
153 * Returns system information about the drawing area.
154 */
155 const WindowSystemInfo& GetWindowInfo() const {
156 return window_info;
157 }
158
159 /**
131 * Gets the framebuffer layout (width, height, and screen regions) 160 * Gets the framebuffer layout (width, height, and screen regions)
132 * @note This method is thread-safe 161 * @note This method is thread-safe
133 */ 162 */
@@ -142,7 +171,7 @@ public:
142 void UpdateCurrentFramebufferLayout(unsigned width, unsigned height); 171 void UpdateCurrentFramebufferLayout(unsigned width, unsigned height);
143 172
144protected: 173protected:
145 EmuWindow(); 174 explicit EmuWindow();
146 virtual ~EmuWindow(); 175 virtual ~EmuWindow();
147 176
148 /** 177 /**
@@ -179,6 +208,8 @@ protected:
179 client_area_height = size.second; 208 client_area_height = size.second;
180 } 209 }
181 210
211 WindowSystemInfo window_info;
212
182private: 213private:
183 /** 214 /**
184 * Handler called when the minimal client area was requested to be changed via SetConfig. 215 * Handler called when the minimal client area was requested to be changed via SetConfig.
diff --git a/src/core/hle/service/nvflinger/buffer_queue.cpp b/src/core/hle/service/nvflinger/buffer_queue.cpp
index 32b6f4b27..f1e3d832a 100644
--- a/src/core/hle/service/nvflinger/buffer_queue.cpp
+++ b/src/core/hle/service/nvflinger/buffer_queue.cpp
@@ -28,6 +28,7 @@ void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer)
28 buffer.slot = slot; 28 buffer.slot = slot;
29 buffer.igbp_buffer = igbp_buffer; 29 buffer.igbp_buffer = igbp_buffer;
30 buffer.status = Buffer::Status::Free; 30 buffer.status = Buffer::Status::Free;
31 free_buffers.push_back(slot);
31 32
32 queue.emplace_back(buffer); 33 queue.emplace_back(buffer);
33 buffer_wait_event.writable->Signal(); 34 buffer_wait_event.writable->Signal();
@@ -35,16 +36,37 @@ void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer)
35 36
36std::optional<std::pair<u32, Service::Nvidia::MultiFence*>> BufferQueue::DequeueBuffer(u32 width, 37std::optional<std::pair<u32, Service::Nvidia::MultiFence*>> BufferQueue::DequeueBuffer(u32 width,
37 u32 height) { 38 u32 height) {
38 auto itr = std::find_if(queue.begin(), queue.end(), [&](const Buffer& buffer) {
39 // Only consider free buffers. Buffers become free once again after they've been Acquired
40 // and Released by the compositor, see the NVFlinger::Compose method.
41 if (buffer.status != Buffer::Status::Free) {
42 return false;
43 }
44 39
45 // Make sure that the parameters match. 40 if (free_buffers.empty()) {
46 return buffer.igbp_buffer.width == width && buffer.igbp_buffer.height == height; 41 return {};
47 }); 42 }
43
44 auto f_itr = free_buffers.begin();
45 auto itr = queue.end();
46
47 while (f_itr != free_buffers.end()) {
48 auto slot = *f_itr;
49 itr = std::find_if(queue.begin(), queue.end(), [&](const Buffer& buffer) {
50 // Only consider free buffers. Buffers become free once again after they've been
51 // Acquired and Released by the compositor, see the NVFlinger::Compose method.
52 if (buffer.status != Buffer::Status::Free) {
53 return false;
54 }
55
56 if (buffer.slot != slot) {
57 return false;
58 }
59
60 // Make sure that the parameters match.
61 return buffer.igbp_buffer.width == width && buffer.igbp_buffer.height == height;
62 });
63
64 if (itr != queue.end()) {
65 free_buffers.erase(f_itr);
66 break;
67 }
68 ++f_itr;
69 }
48 70
49 if (itr == queue.end()) { 71 if (itr == queue.end()) {
50 return {}; 72 return {};
@@ -99,10 +121,18 @@ void BufferQueue::ReleaseBuffer(u32 slot) {
99 ASSERT(itr != queue.end()); 121 ASSERT(itr != queue.end());
100 ASSERT(itr->status == Buffer::Status::Acquired); 122 ASSERT(itr->status == Buffer::Status::Acquired);
101 itr->status = Buffer::Status::Free; 123 itr->status = Buffer::Status::Free;
124 free_buffers.push_back(slot);
102 125
103 buffer_wait_event.writable->Signal(); 126 buffer_wait_event.writable->Signal();
104} 127}
105 128
129void BufferQueue::Disconnect() {
130 queue.clear();
131 queue_sequence.clear();
132 id = 1;
133 layer_id = 1;
134}
135
106u32 BufferQueue::Query(QueryType type) { 136u32 BufferQueue::Query(QueryType type) {
107 LOG_WARNING(Service, "(STUBBED) called type={}", static_cast<u32>(type)); 137 LOG_WARNING(Service, "(STUBBED) called type={}", static_cast<u32>(type));
108 138
diff --git a/src/core/hle/service/nvflinger/buffer_queue.h b/src/core/hle/service/nvflinger/buffer_queue.h
index f4bbfd945..d5f31e567 100644
--- a/src/core/hle/service/nvflinger/buffer_queue.h
+++ b/src/core/hle/service/nvflinger/buffer_queue.h
@@ -87,6 +87,7 @@ public:
87 Service::Nvidia::MultiFence& multi_fence); 87 Service::Nvidia::MultiFence& multi_fence);
88 std::optional<std::reference_wrapper<const Buffer>> AcquireBuffer(); 88 std::optional<std::reference_wrapper<const Buffer>> AcquireBuffer();
89 void ReleaseBuffer(u32 slot); 89 void ReleaseBuffer(u32 slot);
90 void Disconnect();
90 u32 Query(QueryType type); 91 u32 Query(QueryType type);
91 92
92 u32 GetId() const { 93 u32 GetId() const {
@@ -101,6 +102,7 @@ private:
101 u32 id; 102 u32 id;
102 u64 layer_id; 103 u64 layer_id;
103 104
105 std::list<u32> free_buffers;
104 std::vector<Buffer> queue; 106 std::vector<Buffer> queue;
105 std::list<u32> queue_sequence; 107 std::list<u32> queue_sequence;
106 Kernel::EventPair buffer_wait_event; 108 Kernel::EventPair buffer_wait_event;
diff --git a/src/core/hle/service/vi/vi.cpp b/src/core/hle/service/vi/vi.cpp
index 519da74e0..fdc62d05b 100644
--- a/src/core/hle/service/vi/vi.cpp
+++ b/src/core/hle/service/vi/vi.cpp
@@ -513,7 +513,8 @@ private:
513 513
514 auto& buffer_queue = nv_flinger->FindBufferQueue(id); 514 auto& buffer_queue = nv_flinger->FindBufferQueue(id);
515 515
516 if (transaction == TransactionId::Connect) { 516 switch (transaction) {
517 case TransactionId::Connect: {
517 IGBPConnectRequestParcel request{ctx.ReadBuffer()}; 518 IGBPConnectRequestParcel request{ctx.ReadBuffer()};
518 IGBPConnectResponseParcel response{ 519 IGBPConnectResponseParcel response{
519 static_cast<u32>(static_cast<u32>(DisplayResolution::UndockedWidth) * 520 static_cast<u32>(static_cast<u32>(DisplayResolution::UndockedWidth) *
@@ -521,14 +522,18 @@ private:
521 static_cast<u32>(static_cast<u32>(DisplayResolution::UndockedHeight) * 522 static_cast<u32>(static_cast<u32>(DisplayResolution::UndockedHeight) *
522 Settings::values.resolution_factor)}; 523 Settings::values.resolution_factor)};
523 ctx.WriteBuffer(response.Serialize()); 524 ctx.WriteBuffer(response.Serialize());
524 } else if (transaction == TransactionId::SetPreallocatedBuffer) { 525 break;
526 }
527 case TransactionId::SetPreallocatedBuffer: {
525 IGBPSetPreallocatedBufferRequestParcel request{ctx.ReadBuffer()}; 528 IGBPSetPreallocatedBufferRequestParcel request{ctx.ReadBuffer()};
526 529
527 buffer_queue.SetPreallocatedBuffer(request.data.slot, request.buffer); 530 buffer_queue.SetPreallocatedBuffer(request.data.slot, request.buffer);
528 531
529 IGBPSetPreallocatedBufferResponseParcel response{}; 532 IGBPSetPreallocatedBufferResponseParcel response{};
530 ctx.WriteBuffer(response.Serialize()); 533 ctx.WriteBuffer(response.Serialize());
531 } else if (transaction == TransactionId::DequeueBuffer) { 534 break;
535 }
536 case TransactionId::DequeueBuffer: {
532 IGBPDequeueBufferRequestParcel request{ctx.ReadBuffer()}; 537 IGBPDequeueBufferRequestParcel request{ctx.ReadBuffer()};
533 const u32 width{request.data.width}; 538 const u32 width{request.data.width};
534 const u32 height{request.data.height}; 539 const u32 height{request.data.height};
@@ -556,14 +561,18 @@ private:
556 }, 561 },
557 buffer_queue.GetWritableBufferWaitEvent()); 562 buffer_queue.GetWritableBufferWaitEvent());
558 } 563 }
559 } else if (transaction == TransactionId::RequestBuffer) { 564 break;
565 }
566 case TransactionId::RequestBuffer: {
560 IGBPRequestBufferRequestParcel request{ctx.ReadBuffer()}; 567 IGBPRequestBufferRequestParcel request{ctx.ReadBuffer()};
561 568
562 auto& buffer = buffer_queue.RequestBuffer(request.slot); 569 auto& buffer = buffer_queue.RequestBuffer(request.slot);
563 570
564 IGBPRequestBufferResponseParcel response{buffer}; 571 IGBPRequestBufferResponseParcel response{buffer};
565 ctx.WriteBuffer(response.Serialize()); 572 ctx.WriteBuffer(response.Serialize());
566 } else if (transaction == TransactionId::QueueBuffer) { 573 break;
574 }
575 case TransactionId::QueueBuffer: {
567 IGBPQueueBufferRequestParcel request{ctx.ReadBuffer()}; 576 IGBPQueueBufferRequestParcel request{ctx.ReadBuffer()};
568 577
569 buffer_queue.QueueBuffer(request.data.slot, request.data.transform, 578 buffer_queue.QueueBuffer(request.data.slot, request.data.transform,
@@ -572,7 +581,9 @@ private:
572 581
573 IGBPQueueBufferResponseParcel response{1280, 720}; 582 IGBPQueueBufferResponseParcel response{1280, 720};
574 ctx.WriteBuffer(response.Serialize()); 583 ctx.WriteBuffer(response.Serialize());
575 } else if (transaction == TransactionId::Query) { 584 break;
585 }
586 case TransactionId::Query: {
576 IGBPQueryRequestParcel request{ctx.ReadBuffer()}; 587 IGBPQueryRequestParcel request{ctx.ReadBuffer()};
577 588
578 const u32 value = 589 const u32 value =
@@ -580,15 +591,30 @@ private:
580 591
581 IGBPQueryResponseParcel response{value}; 592 IGBPQueryResponseParcel response{value};
582 ctx.WriteBuffer(response.Serialize()); 593 ctx.WriteBuffer(response.Serialize());
583 } else if (transaction == TransactionId::CancelBuffer) { 594 break;
595 }
596 case TransactionId::CancelBuffer: {
584 LOG_CRITICAL(Service_VI, "(STUBBED) called, transaction=CancelBuffer"); 597 LOG_CRITICAL(Service_VI, "(STUBBED) called, transaction=CancelBuffer");
585 } else if (transaction == TransactionId::Disconnect || 598 break;
586 transaction == TransactionId::DetachBuffer) { 599 }
600 case TransactionId::Disconnect: {
601 LOG_WARNING(Service_VI, "(STUBBED) called, transaction=Disconnect");
602 const auto buffer = ctx.ReadBuffer();
603
604 buffer_queue.Disconnect();
605
606 IGBPEmptyResponseParcel response{};
607 ctx.WriteBuffer(response.Serialize());
608 break;
609 }
610 case TransactionId::DetachBuffer: {
587 const auto buffer = ctx.ReadBuffer(); 611 const auto buffer = ctx.ReadBuffer();
588 612
589 IGBPEmptyResponseParcel response{}; 613 IGBPEmptyResponseParcel response{};
590 ctx.WriteBuffer(response.Serialize()); 614 ctx.WriteBuffer(response.Serialize());
591 } else { 615 break;
616 }
617 default:
592 ASSERT_MSG(false, "Unimplemented"); 618 ASSERT_MSG(false, "Unimplemented");
593 } 619 }
594 620
diff --git a/src/video_core/engines/maxwell_3d.h b/src/video_core/engines/maxwell_3d.h
index d24c9f657..4637ddabd 100644
--- a/src/video_core/engines/maxwell_3d.h
+++ b/src/video_core/engines/maxwell_3d.h
@@ -312,6 +312,35 @@ public:
312 } 312 }
313 }; 313 };
314 314
315 struct MsaaSampleLocation {
316 union {
317 BitField<0, 4, u32> x0;
318 BitField<4, 4, u32> y0;
319 BitField<8, 4, u32> x1;
320 BitField<12, 4, u32> y1;
321 BitField<16, 4, u32> x2;
322 BitField<20, 4, u32> y2;
323 BitField<24, 4, u32> x3;
324 BitField<28, 4, u32> y3;
325 };
326
327 constexpr std::pair<u32, u32> Location(int index) const {
328 switch (index) {
329 case 0:
330 return {x0, y0};
331 case 1:
332 return {x1, y1};
333 case 2:
334 return {x2, y2};
335 case 3:
336 return {x3, y3};
337 default:
338 UNREACHABLE();
339 return {0, 0};
340 }
341 }
342 };
343
315 enum class DepthMode : u32 { 344 enum class DepthMode : u32 {
316 MinusOneToOne = 0, 345 MinusOneToOne = 0,
317 ZeroToOne = 1, 346 ZeroToOne = 1,
@@ -793,7 +822,13 @@ public:
793 822
794 u32 rt_separate_frag_data; 823 u32 rt_separate_frag_data;
795 824
796 INSERT_UNION_PADDING_WORDS(0xC); 825 INSERT_UNION_PADDING_WORDS(0x1);
826
827 u32 multisample_raster_enable;
828 u32 multisample_raster_samples;
829 std::array<u32, 4> multisample_sample_mask;
830
831 INSERT_UNION_PADDING_WORDS(0x5);
797 832
798 struct { 833 struct {
799 u32 address_high; 834 u32 address_high;
@@ -830,7 +865,16 @@ public:
830 865
831 std::array<VertexAttribute, NumVertexAttributes> vertex_attrib_format; 866 std::array<VertexAttribute, NumVertexAttributes> vertex_attrib_format;
832 867
833 INSERT_UNION_PADDING_WORDS(0xF); 868 std::array<MsaaSampleLocation, 4> multisample_sample_locations;
869
870 INSERT_UNION_PADDING_WORDS(0x2);
871
872 union {
873 BitField<0, 1, u32> enable;
874 BitField<4, 3, u32> target;
875 } multisample_coverage_to_color;
876
877 INSERT_UNION_PADDING_WORDS(0x8);
834 878
835 struct { 879 struct {
836 union { 880 union {
@@ -943,7 +987,7 @@ public:
943 987
944 CounterReset counter_reset; 988 CounterReset counter_reset;
945 989
946 INSERT_UNION_PADDING_WORDS(0x1); 990 u32 multisample_enable;
947 991
948 u32 zeta_enable; 992 u32 zeta_enable;
949 993
@@ -1007,7 +1051,11 @@ public:
1007 1051
1008 float polygon_offset_units; 1052 float polygon_offset_units;
1009 1053
1010 INSERT_UNION_PADDING_WORDS(0x11); 1054 INSERT_UNION_PADDING_WORDS(0x4);
1055
1056 Tegra::Texture::MsaaMode multisample_mode;
1057
1058 INSERT_UNION_PADDING_WORDS(0xC);
1011 1059
1012 union { 1060 union {
1013 BitField<2, 1, u32> coord_origin; 1061 BitField<2, 1, u32> coord_origin;
@@ -1507,12 +1555,17 @@ ASSERT_REG_POSITION(stencil_back_func_ref, 0x3D5);
1507ASSERT_REG_POSITION(stencil_back_mask, 0x3D6); 1555ASSERT_REG_POSITION(stencil_back_mask, 0x3D6);
1508ASSERT_REG_POSITION(stencil_back_func_mask, 0x3D7); 1556ASSERT_REG_POSITION(stencil_back_func_mask, 0x3D7);
1509ASSERT_REG_POSITION(color_mask_common, 0x3E4); 1557ASSERT_REG_POSITION(color_mask_common, 0x3E4);
1510ASSERT_REG_POSITION(rt_separate_frag_data, 0x3EB);
1511ASSERT_REG_POSITION(depth_bounds, 0x3E7); 1558ASSERT_REG_POSITION(depth_bounds, 0x3E7);
1559ASSERT_REG_POSITION(rt_separate_frag_data, 0x3EB);
1560ASSERT_REG_POSITION(multisample_raster_enable, 0x3ED);
1561ASSERT_REG_POSITION(multisample_raster_samples, 0x3EE);
1562ASSERT_REG_POSITION(multisample_sample_mask, 0x3EF);
1512ASSERT_REG_POSITION(zeta, 0x3F8); 1563ASSERT_REG_POSITION(zeta, 0x3F8);
1513ASSERT_REG_POSITION(clear_flags, 0x43E); 1564ASSERT_REG_POSITION(clear_flags, 0x43E);
1514ASSERT_REG_POSITION(fill_rectangle, 0x44F); 1565ASSERT_REG_POSITION(fill_rectangle, 0x44F);
1515ASSERT_REG_POSITION(vertex_attrib_format, 0x458); 1566ASSERT_REG_POSITION(vertex_attrib_format, 0x458);
1567ASSERT_REG_POSITION(multisample_sample_locations, 0x478);
1568ASSERT_REG_POSITION(multisample_coverage_to_color, 0x47E);
1516ASSERT_REG_POSITION(rt_control, 0x487); 1569ASSERT_REG_POSITION(rt_control, 0x487);
1517ASSERT_REG_POSITION(zeta_width, 0x48a); 1570ASSERT_REG_POSITION(zeta_width, 0x48a);
1518ASSERT_REG_POSITION(zeta_height, 0x48b); 1571ASSERT_REG_POSITION(zeta_height, 0x48b);
@@ -1545,11 +1598,12 @@ ASSERT_REG_POSITION(samplecnt_enable, 0x545);
1545ASSERT_REG_POSITION(point_size, 0x546); 1598ASSERT_REG_POSITION(point_size, 0x546);
1546ASSERT_REG_POSITION(point_sprite_enable, 0x548); 1599ASSERT_REG_POSITION(point_sprite_enable, 0x548);
1547ASSERT_REG_POSITION(counter_reset, 0x54C); 1600ASSERT_REG_POSITION(counter_reset, 0x54C);
1601ASSERT_REG_POSITION(multisample_enable, 0x54D);
1548ASSERT_REG_POSITION(zeta_enable, 0x54E); 1602ASSERT_REG_POSITION(zeta_enable, 0x54E);
1549ASSERT_REG_POSITION(multisample_control, 0x54F); 1603ASSERT_REG_POSITION(multisample_control, 0x54F);
1550ASSERT_REG_POSITION(condition, 0x554); 1604ASSERT_REG_POSITION(condition, 0x554);
1551ASSERT_REG_POSITION(tsc, 0x557); 1605ASSERT_REG_POSITION(tsc, 0x557);
1552ASSERT_REG_POSITION(polygon_offset_factor, 0x55b); 1606ASSERT_REG_POSITION(polygon_offset_factor, 0x55B);
1553ASSERT_REG_POSITION(tic, 0x55D); 1607ASSERT_REG_POSITION(tic, 0x55D);
1554ASSERT_REG_POSITION(stencil_two_side_enable, 0x565); 1608ASSERT_REG_POSITION(stencil_two_side_enable, 0x565);
1555ASSERT_REG_POSITION(stencil_back_op_fail, 0x566); 1609ASSERT_REG_POSITION(stencil_back_op_fail, 0x566);
@@ -1558,6 +1612,7 @@ ASSERT_REG_POSITION(stencil_back_op_zpass, 0x568);
1558ASSERT_REG_POSITION(stencil_back_func_func, 0x569); 1612ASSERT_REG_POSITION(stencil_back_func_func, 0x569);
1559ASSERT_REG_POSITION(framebuffer_srgb, 0x56E); 1613ASSERT_REG_POSITION(framebuffer_srgb, 0x56E);
1560ASSERT_REG_POSITION(polygon_offset_units, 0x56F); 1614ASSERT_REG_POSITION(polygon_offset_units, 0x56F);
1615ASSERT_REG_POSITION(multisample_mode, 0x574);
1561ASSERT_REG_POSITION(point_coord_replace, 0x581); 1616ASSERT_REG_POSITION(point_coord_replace, 0x581);
1562ASSERT_REG_POSITION(code_address, 0x582); 1617ASSERT_REG_POSITION(code_address, 0x582);
1563ASSERT_REG_POSITION(draw, 0x585); 1618ASSERT_REG_POSITION(draw, 0x585);
diff --git a/src/video_core/engines/shader_bytecode.h b/src/video_core/engines/shader_bytecode.h
index 498936f0c..c66c66f6c 100644
--- a/src/video_core/engines/shader_bytecode.h
+++ b/src/video_core/engines/shader_bytecode.h
@@ -290,6 +290,23 @@ enum class VmadShr : u64 {
290 Shr15 = 2, 290 Shr15 = 2,
291}; 291};
292 292
293enum class VmnmxType : u64 {
294 Bits8,
295 Bits16,
296 Bits32,
297};
298
299enum class VmnmxOperation : u64 {
300 Mrg_16H = 0,
301 Mrg_16L = 1,
302 Mrg_8B0 = 2,
303 Mrg_8B2 = 3,
304 Acc = 4,
305 Min = 5,
306 Max = 6,
307 Nop = 7,
308};
309
293enum class XmadMode : u64 { 310enum class XmadMode : u64 {
294 None = 0, 311 None = 0,
295 CLo = 1, 312 CLo = 1,
@@ -1651,6 +1668,42 @@ union Instruction {
1651 } vmad; 1668 } vmad;
1652 1669
1653 union { 1670 union {
1671 BitField<54, 1, u64> is_dest_signed;
1672 BitField<48, 1, u64> is_src_a_signed;
1673 BitField<49, 1, u64> is_src_b_signed;
1674 BitField<37, 2, u64> src_format_a;
1675 BitField<29, 2, u64> src_format_b;
1676 BitField<56, 1, u64> mx;
1677 BitField<55, 1, u64> sat;
1678 BitField<36, 2, u64> selector_a;
1679 BitField<28, 2, u64> selector_b;
1680 BitField<50, 1, u64> is_op_b_register;
1681 BitField<51, 3, VmnmxOperation> operation;
1682
1683 VmnmxType SourceFormatA() const {
1684 switch (src_format_a) {
1685 case 0b11:
1686 return VmnmxType::Bits32;
1687 case 0b10:
1688 return VmnmxType::Bits16;
1689 default:
1690 return VmnmxType::Bits8;
1691 }
1692 }
1693
1694 VmnmxType SourceFormatB() const {
1695 switch (src_format_b) {
1696 case 0b11:
1697 return VmnmxType::Bits32;
1698 case 0b10:
1699 return VmnmxType::Bits16;
1700 default:
1701 return VmnmxType::Bits8;
1702 }
1703 }
1704 } vmnmx;
1705
1706 union {
1654 BitField<20, 16, u64> imm20_16; 1707 BitField<20, 16, u64> imm20_16;
1655 BitField<35, 1, u64> high_b_rr; // used on RR 1708 BitField<35, 1, u64> high_b_rr; // used on RR
1656 BitField<36, 1, u64> product_shift_left; 1709 BitField<36, 1, u64> product_shift_left;
@@ -1763,6 +1816,7 @@ public:
1763 MEMBAR, 1816 MEMBAR,
1764 VMAD, 1817 VMAD,
1765 VSETP, 1818 VSETP,
1819 VMNMX,
1766 FFMA_IMM, // Fused Multiply and Add 1820 FFMA_IMM, // Fused Multiply and Add
1767 FFMA_CR, 1821 FFMA_CR,
1768 FFMA_RC, 1822 FFMA_RC,
@@ -2070,6 +2124,7 @@ private:
2070 INST("1110111110011---", Id::MEMBAR, Type::Trivial, "MEMBAR"), 2124 INST("1110111110011---", Id::MEMBAR, Type::Trivial, "MEMBAR"),
2071 INST("01011111--------", Id::VMAD, Type::Video, "VMAD"), 2125 INST("01011111--------", Id::VMAD, Type::Video, "VMAD"),
2072 INST("0101000011110---", Id::VSETP, Type::Video, "VSETP"), 2126 INST("0101000011110---", Id::VSETP, Type::Video, "VSETP"),
2127 INST("0011101---------", Id::VMNMX, Type::Video, "VMNMX"),
2073 INST("0011001-1-------", Id::FFMA_IMM, Type::Ffma, "FFMA_IMM"), 2128 INST("0011001-1-------", Id::FFMA_IMM, Type::Ffma, "FFMA_IMM"),
2074 INST("010010011-------", Id::FFMA_CR, Type::Ffma, "FFMA_CR"), 2129 INST("010010011-------", Id::FFMA_CR, Type::Ffma, "FFMA_CR"),
2075 INST("010100011-------", Id::FFMA_RC, Type::Ffma, "FFMA_RC"), 2130 INST("010100011-------", Id::FFMA_RC, Type::Ffma, "FFMA_RC"),
@@ -2170,7 +2225,7 @@ private:
2170 INST("0011011-11111---", Id::SHF_LEFT_IMM, Type::Shift, "SHF_LEFT_IMM"), 2225 INST("0011011-11111---", Id::SHF_LEFT_IMM, Type::Shift, "SHF_LEFT_IMM"),
2171 INST("0100110011100---", Id::I2I_C, Type::Conversion, "I2I_C"), 2226 INST("0100110011100---", Id::I2I_C, Type::Conversion, "I2I_C"),
2172 INST("0101110011100---", Id::I2I_R, Type::Conversion, "I2I_R"), 2227 INST("0101110011100---", Id::I2I_R, Type::Conversion, "I2I_R"),
2173 INST("0011101-11100---", Id::I2I_IMM, Type::Conversion, "I2I_IMM"), 2228 INST("0011100-11100---", Id::I2I_IMM, Type::Conversion, "I2I_IMM"),
2174 INST("0100110010111---", Id::I2F_C, Type::Conversion, "I2F_C"), 2229 INST("0100110010111---", Id::I2F_C, Type::Conversion, "I2F_C"),
2175 INST("0101110010111---", Id::I2F_R, Type::Conversion, "I2F_R"), 2230 INST("0101110010111---", Id::I2F_R, Type::Conversion, "I2F_R"),
2176 INST("0011100-10111---", Id::I2F_IMM, Type::Conversion, "I2F_IMM"), 2231 INST("0011100-10111---", Id::I2F_IMM, Type::Conversion, "I2F_IMM"),
diff --git a/src/video_core/renderer_vulkan/declarations.h b/src/video_core/renderer_vulkan/declarations.h
index 323bf6b39..89a035ca4 100644
--- a/src/video_core/renderer_vulkan/declarations.h
+++ b/src/video_core/renderer_vulkan/declarations.h
@@ -39,6 +39,7 @@ using UniqueFence = UniqueHandle<vk::Fence>;
39using UniqueFramebuffer = UniqueHandle<vk::Framebuffer>; 39using UniqueFramebuffer = UniqueHandle<vk::Framebuffer>;
40using UniqueImage = UniqueHandle<vk::Image>; 40using UniqueImage = UniqueHandle<vk::Image>;
41using UniqueImageView = UniqueHandle<vk::ImageView>; 41using UniqueImageView = UniqueHandle<vk::ImageView>;
42using UniqueInstance = UniqueHandle<vk::Instance>;
42using UniqueIndirectCommandsLayoutNVX = UniqueHandle<vk::IndirectCommandsLayoutNVX>; 43using UniqueIndirectCommandsLayoutNVX = UniqueHandle<vk::IndirectCommandsLayoutNVX>;
43using UniqueObjectTableNVX = UniqueHandle<vk::ObjectTableNVX>; 44using UniqueObjectTableNVX = UniqueHandle<vk::ObjectTableNVX>;
44using UniquePipeline = UniqueHandle<vk::Pipeline>; 45using UniquePipeline = UniqueHandle<vk::Pipeline>;
@@ -50,6 +51,7 @@ using UniqueSampler = UniqueHandle<vk::Sampler>;
50using UniqueSamplerYcbcrConversion = UniqueHandle<vk::SamplerYcbcrConversion>; 51using UniqueSamplerYcbcrConversion = UniqueHandle<vk::SamplerYcbcrConversion>;
51using UniqueSemaphore = UniqueHandle<vk::Semaphore>; 52using UniqueSemaphore = UniqueHandle<vk::Semaphore>;
52using UniqueShaderModule = UniqueHandle<vk::ShaderModule>; 53using UniqueShaderModule = UniqueHandle<vk::ShaderModule>;
54using UniqueSurfaceKHR = UniqueHandle<vk::SurfaceKHR>;
53using UniqueSwapchainKHR = UniqueHandle<vk::SwapchainKHR>; 55using UniqueSwapchainKHR = UniqueHandle<vk::SwapchainKHR>;
54using UniqueValidationCacheEXT = UniqueHandle<vk::ValidationCacheEXT>; 56using UniqueValidationCacheEXT = UniqueHandle<vk::ValidationCacheEXT>;
55using UniqueDebugReportCallbackEXT = UniqueHandle<vk::DebugReportCallbackEXT>; 57using UniqueDebugReportCallbackEXT = UniqueHandle<vk::DebugReportCallbackEXT>;
diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.cpp b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
index 6953aaafe..9cdb4b627 100644
--- a/src/video_core/renderer_vulkan/renderer_vulkan.cpp
+++ b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
@@ -2,13 +2,18 @@
2// Licensed under GPLv2 or any later version 2// Licensed under GPLv2 or any later version
3// Refer to the license.txt file included. 3// Refer to the license.txt file included.
4 4
5#include <algorithm>
6#include <array>
7#include <cstring>
5#include <memory> 8#include <memory>
6#include <optional> 9#include <optional>
10#include <string>
7#include <vector> 11#include <vector>
8 12
9#include <fmt/format.h> 13#include <fmt/format.h>
10 14
11#include "common/assert.h" 15#include "common/assert.h"
16#include "common/dynamic_library.h"
12#include "common/logging/log.h" 17#include "common/logging/log.h"
13#include "common/telemetry.h" 18#include "common/telemetry.h"
14#include "core/core.h" 19#include "core/core.h"
@@ -30,15 +35,30 @@
30#include "video_core/renderer_vulkan/vk_state_tracker.h" 35#include "video_core/renderer_vulkan/vk_state_tracker.h"
31#include "video_core/renderer_vulkan/vk_swapchain.h" 36#include "video_core/renderer_vulkan/vk_swapchain.h"
32 37
38// Include these late to avoid changing Vulkan-Hpp's dynamic dispatcher size
39#ifdef _WIN32
40#include <windows.h>
41// ensure include order
42#include <vulkan/vulkan_win32.h>
43#endif
44
45#ifdef __linux__
46#include <X11/Xlib.h>
47#include <vulkan/vulkan_wayland.h>
48#include <vulkan/vulkan_xlib.h>
49#endif
50
33namespace Vulkan { 51namespace Vulkan {
34 52
35namespace { 53namespace {
36 54
55using Core::Frontend::WindowSystemType;
56
37VkBool32 DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT severity_, 57VkBool32 DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT severity_,
38 VkDebugUtilsMessageTypeFlagsEXT type, 58 VkDebugUtilsMessageTypeFlagsEXT type,
39 const VkDebugUtilsMessengerCallbackDataEXT* data, 59 const VkDebugUtilsMessengerCallbackDataEXT* data,
40 [[maybe_unused]] void* user_data) { 60 [[maybe_unused]] void* user_data) {
41 const vk::DebugUtilsMessageSeverityFlagBitsEXT severity{severity_}; 61 const auto severity{static_cast<vk::DebugUtilsMessageSeverityFlagBitsEXT>(severity_)};
42 const char* message{data->pMessage}; 62 const char* message{data->pMessage};
43 63
44 if (severity & vk::DebugUtilsMessageSeverityFlagBitsEXT::eError) { 64 if (severity & vk::DebugUtilsMessageSeverityFlagBitsEXT::eError) {
@@ -53,6 +73,110 @@ VkBool32 DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT severity_,
53 return VK_FALSE; 73 return VK_FALSE;
54} 74}
55 75
76Common::DynamicLibrary OpenVulkanLibrary() {
77 Common::DynamicLibrary library;
78#ifdef __APPLE__
79 // Check if a path to a specific Vulkan library has been specified.
80 char* libvulkan_env = getenv("LIBVULKAN_PATH");
81 if (!libvulkan_env || !library.Open(libvulkan_env)) {
82 // Use the libvulkan.dylib from the application bundle.
83 std::string filename = File::GetBundleDirectory() + "/Contents/Frameworks/libvulkan.dylib";
84 library.Open(filename.c_str());
85 }
86#else
87 std::string filename = Common::DynamicLibrary::GetVersionedFilename("vulkan", 1);
88 if (!library.Open(filename.c_str())) {
89 // Android devices may not have libvulkan.so.1, only libvulkan.so.
90 filename = Common::DynamicLibrary::GetVersionedFilename("vulkan");
91 library.Open(filename.c_str());
92 }
93#endif
94 return library;
95}
96
97UniqueInstance CreateInstance(Common::DynamicLibrary& library, vk::DispatchLoaderDynamic& dld,
98 WindowSystemType window_type = WindowSystemType::Headless,
99 bool enable_layers = false) {
100 if (!library.IsOpen()) {
101 LOG_ERROR(Render_Vulkan, "Vulkan library not available");
102 return UniqueInstance{};
103 }
104 PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
105 if (!library.GetSymbol("vkGetInstanceProcAddr", &vkGetInstanceProcAddr)) {
106 LOG_ERROR(Render_Vulkan, "vkGetInstanceProcAddr not present in Vulkan");
107 return UniqueInstance{};
108 }
109 dld.init(vkGetInstanceProcAddr);
110
111 std::vector<const char*> extensions;
112 extensions.reserve(4);
113 switch (window_type) {
114 case Core::Frontend::WindowSystemType::Headless:
115 break;
116#ifdef _WIN32
117 case Core::Frontend::WindowSystemType::Windows:
118 extensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
119 break;
120#endif
121#ifdef __linux__
122 case Core::Frontend::WindowSystemType::X11:
123 extensions.push_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
124 break;
125 case Core::Frontend::WindowSystemType::Wayland:
126 extensions.push_back(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
127 break;
128#endif
129 default:
130 LOG_ERROR(Render_Vulkan, "Presentation not supported on this platform");
131 break;
132 }
133 if (window_type != Core::Frontend::WindowSystemType::Headless) {
134 extensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
135 }
136 if (enable_layers) {
137 extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
138 }
139
140 u32 num_properties;
141 if (vk::enumerateInstanceExtensionProperties(nullptr, &num_properties, nullptr, dld) !=
142 vk::Result::eSuccess) {
143 LOG_ERROR(Render_Vulkan, "Failed to query number of extension properties");
144 return UniqueInstance{};
145 }
146 std::vector<vk::ExtensionProperties> properties(num_properties);
147 if (vk::enumerateInstanceExtensionProperties(nullptr, &num_properties, properties.data(),
148 dld) != vk::Result::eSuccess) {
149 LOG_ERROR(Render_Vulkan, "Failed to query extension properties");
150 return UniqueInstance{};
151 }
152
153 for (const char* extension : extensions) {
154 const auto it =
155 std::find_if(properties.begin(), properties.end(), [extension](const auto& prop) {
156 return !std::strcmp(extension, prop.extensionName);
157 });
158 if (it == properties.end()) {
159 LOG_ERROR(Render_Vulkan, "Required instance extension {} is not available", extension);
160 return UniqueInstance{};
161 }
162 }
163
164 const vk::ApplicationInfo application_info("yuzu Emulator", VK_MAKE_VERSION(0, 1, 0),
165 "yuzu Emulator", VK_MAKE_VERSION(0, 1, 0),
166 VK_API_VERSION_1_1);
167 const std::array layers = {"VK_LAYER_LUNARG_standard_validation"};
168 const vk::InstanceCreateInfo instance_ci(
169 {}, &application_info, enable_layers ? static_cast<u32>(layers.size()) : 0, layers.data(),
170 static_cast<u32>(extensions.size()), extensions.data());
171 vk::Instance unsafe_instance;
172 if (vk::createInstance(&instance_ci, nullptr, &unsafe_instance, dld) != vk::Result::eSuccess) {
173 LOG_ERROR(Render_Vulkan, "Failed to create Vulkan instance");
174 return UniqueInstance{};
175 }
176 dld.init(unsafe_instance);
177 return UniqueInstance(unsafe_instance, {nullptr, dld});
178}
179
56std::string GetReadableVersion(u32 version) { 180std::string GetReadableVersion(u32 version) {
57 return fmt::format("{}.{}.{}", VK_VERSION_MAJOR(version), VK_VERSION_MINOR(version), 181 return fmt::format("{}.{}.{}", VK_VERSION_MAJOR(version), VK_VERSION_MINOR(version),
58 VK_VERSION_PATCH(version)); 182 VK_VERSION_PATCH(version));
@@ -147,27 +271,12 @@ bool RendererVulkan::TryPresent(int /*timeout_ms*/) {
147} 271}
148 272
149bool RendererVulkan::Init() { 273bool RendererVulkan::Init() {
150 PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr{}; 274 library = OpenVulkanLibrary();
151 render_window.RetrieveVulkanHandlers(&vkGetInstanceProcAddr, &instance, &surface); 275 instance = CreateInstance(library, dld, render_window.GetWindowInfo().type,
152 const vk::DispatchLoaderDynamic dldi(instance, vkGetInstanceProcAddr); 276 Settings::values.renderer_debug);
153 277 if (!instance || !CreateDebugCallback() || !CreateSurface() || !PickDevices()) {
154 std::optional<vk::DebugUtilsMessengerEXT> callback;
155 if (Settings::values.renderer_debug && dldi.vkCreateDebugUtilsMessengerEXT) {
156 callback = CreateDebugCallback(dldi);
157 if (!callback) {
158 return false;
159 }
160 }
161
162 if (!PickDevices(dldi)) {
163 if (callback) {
164 instance.destroy(*callback, nullptr, dldi);
165 }
166 return false; 278 return false;
167 } 279 }
168 debug_callback = UniqueDebugUtilsMessengerEXT(
169 *callback, vk::ObjectDestroy<vk::Instance, vk::DispatchLoaderDynamic>(
170 instance, nullptr, device->GetDispatchLoader()));
171 280
172 Report(); 281 Report();
173 282
@@ -176,7 +285,7 @@ bool RendererVulkan::Init() {
176 resource_manager = std::make_unique<VKResourceManager>(*device); 285 resource_manager = std::make_unique<VKResourceManager>(*device);
177 286
178 const auto& framebuffer = render_window.GetFramebufferLayout(); 287 const auto& framebuffer = render_window.GetFramebufferLayout();
179 swapchain = std::make_unique<VKSwapchain>(surface, *device); 288 swapchain = std::make_unique<VKSwapchain>(*surface, *device);
180 swapchain->Create(framebuffer.width, framebuffer.height, false); 289 swapchain->Create(framebuffer.width, framebuffer.height, false);
181 290
182 state_tracker = std::make_unique<StateTracker>(system); 291 state_tracker = std::make_unique<StateTracker>(system);
@@ -213,8 +322,10 @@ void RendererVulkan::ShutDown() {
213 device.reset(); 322 device.reset();
214} 323}
215 324
216std::optional<vk::DebugUtilsMessengerEXT> RendererVulkan::CreateDebugCallback( 325bool RendererVulkan::CreateDebugCallback() {
217 const vk::DispatchLoaderDynamic& dldi) { 326 if (!Settings::values.renderer_debug) {
327 return true;
328 }
218 const vk::DebugUtilsMessengerCreateInfoEXT callback_ci( 329 const vk::DebugUtilsMessengerCreateInfoEXT callback_ci(
219 {}, 330 {},
220 vk::DebugUtilsMessageSeverityFlagBitsEXT::eError | 331 vk::DebugUtilsMessageSeverityFlagBitsEXT::eError |
@@ -225,32 +336,88 @@ std::optional<vk::DebugUtilsMessengerEXT> RendererVulkan::CreateDebugCallback(
225 vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation | 336 vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation |
226 vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance, 337 vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance,
227 &DebugCallback, nullptr); 338 &DebugCallback, nullptr);
228 vk::DebugUtilsMessengerEXT callback; 339 vk::DebugUtilsMessengerEXT unsafe_callback;
229 if (instance.createDebugUtilsMessengerEXT(&callback_ci, nullptr, &callback, dldi) != 340 if (instance->createDebugUtilsMessengerEXT(&callback_ci, nullptr, &unsafe_callback, dld) !=
230 vk::Result::eSuccess) { 341 vk::Result::eSuccess) {
231 LOG_ERROR(Render_Vulkan, "Failed to create debug callback"); 342 LOG_ERROR(Render_Vulkan, "Failed to create debug callback");
232 return {}; 343 return false;
344 }
345 debug_callback = UniqueDebugUtilsMessengerEXT(unsafe_callback, {*instance, nullptr, dld});
346 return true;
347}
348
349bool RendererVulkan::CreateSurface() {
350 [[maybe_unused]] const auto& window_info = render_window.GetWindowInfo();
351 VkSurfaceKHR unsafe_surface = nullptr;
352
353#ifdef _WIN32
354 if (window_info.type == Core::Frontend::WindowSystemType::Windows) {
355 const HWND hWnd = static_cast<HWND>(window_info.render_surface);
356 const VkWin32SurfaceCreateInfoKHR win32_ci{VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
357 nullptr, 0, nullptr, hWnd};
358 const auto vkCreateWin32SurfaceKHR = reinterpret_cast<PFN_vkCreateWin32SurfaceKHR>(
359 dld.vkGetInstanceProcAddr(*instance, "vkCreateWin32SurfaceKHR"));
360 if (!vkCreateWin32SurfaceKHR || vkCreateWin32SurfaceKHR(instance.get(), &win32_ci, nullptr,
361 &unsafe_surface) != VK_SUCCESS) {
362 LOG_ERROR(Render_Vulkan, "Failed to initialize Win32 surface");
363 return false;
364 }
365 }
366#endif
367#ifdef __linux__
368 if (window_info.type == Core::Frontend::WindowSystemType::X11) {
369 const VkXlibSurfaceCreateInfoKHR xlib_ci{
370 VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, nullptr, 0,
371 static_cast<Display*>(window_info.display_connection),
372 reinterpret_cast<Window>(window_info.render_surface)};
373 const auto vkCreateXlibSurfaceKHR = reinterpret_cast<PFN_vkCreateXlibSurfaceKHR>(
374 dld.vkGetInstanceProcAddr(*instance, "vkCreateXlibSurfaceKHR"));
375 if (!vkCreateXlibSurfaceKHR || vkCreateXlibSurfaceKHR(instance.get(), &xlib_ci, nullptr,
376 &unsafe_surface) != VK_SUCCESS) {
377 LOG_ERROR(Render_Vulkan, "Failed to initialize Xlib surface");
378 return false;
379 }
380 }
381 if (window_info.type == Core::Frontend::WindowSystemType::Wayland) {
382 const VkWaylandSurfaceCreateInfoKHR wayland_ci{
383 VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR, nullptr, 0,
384 static_cast<wl_display*>(window_info.display_connection),
385 static_cast<wl_surface*>(window_info.render_surface)};
386 const auto vkCreateWaylandSurfaceKHR = reinterpret_cast<PFN_vkCreateWaylandSurfaceKHR>(
387 dld.vkGetInstanceProcAddr(*instance, "vkCreateWaylandSurfaceKHR"));
388 if (!vkCreateWaylandSurfaceKHR ||
389 vkCreateWaylandSurfaceKHR(instance.get(), &wayland_ci, nullptr, &unsafe_surface) !=
390 VK_SUCCESS) {
391 LOG_ERROR(Render_Vulkan, "Failed to initialize Wayland surface");
392 return false;
393 }
394 }
395#endif
396 if (!unsafe_surface) {
397 LOG_ERROR(Render_Vulkan, "Presentation not supported on this platform");
398 return false;
233 } 399 }
234 return callback; 400
401 surface = UniqueSurfaceKHR(unsafe_surface, {*instance, nullptr, dld});
402 return true;
235} 403}
236 404
237bool RendererVulkan::PickDevices(const vk::DispatchLoaderDynamic& dldi) { 405bool RendererVulkan::PickDevices() {
238 const auto devices = instance.enumeratePhysicalDevices(dldi); 406 const auto devices = instance->enumeratePhysicalDevices(dld);
239 407
240 // TODO(Rodrigo): Choose device from config file
241 const s32 device_index = Settings::values.vulkan_device; 408 const s32 device_index = Settings::values.vulkan_device;
242 if (device_index < 0 || device_index >= static_cast<s32>(devices.size())) { 409 if (device_index < 0 || device_index >= static_cast<s32>(devices.size())) {
243 LOG_ERROR(Render_Vulkan, "Invalid device index {}!", device_index); 410 LOG_ERROR(Render_Vulkan, "Invalid device index {}!", device_index);
244 return false; 411 return false;
245 } 412 }
246 const vk::PhysicalDevice physical_device = devices[device_index]; 413 const vk::PhysicalDevice physical_device = devices[static_cast<std::size_t>(device_index)];
247 414
248 if (!VKDevice::IsSuitable(dldi, physical_device, surface)) { 415 if (!VKDevice::IsSuitable(physical_device, *surface, dld)) {
249 return false; 416 return false;
250 } 417 }
251 418
252 device = std::make_unique<VKDevice>(dldi, physical_device, surface); 419 device = std::make_unique<VKDevice>(dld, physical_device, *surface);
253 return device->Create(dldi, instance); 420 return device->Create(*instance);
254} 421}
255 422
256void RendererVulkan::Report() const { 423void RendererVulkan::Report() const {
@@ -276,4 +443,33 @@ void RendererVulkan::Report() const {
276 telemetry_session.AddField(field, "GPU_Vulkan_Extensions", extensions); 443 telemetry_session.AddField(field, "GPU_Vulkan_Extensions", extensions);
277} 444}
278 445
446std::vector<std::string> RendererVulkan::EnumerateDevices() {
447 // Avoid putting DispatchLoaderDynamic, it's too large
448 auto dld_memory = std::make_unique<vk::DispatchLoaderDynamic>();
449 auto& dld = *dld_memory;
450
451 Common::DynamicLibrary library = OpenVulkanLibrary();
452 UniqueInstance instance = CreateInstance(library, dld);
453 if (!instance) {
454 return {};
455 }
456
457 u32 num_devices;
458 if (instance->enumeratePhysicalDevices(&num_devices, nullptr, dld) != vk::Result::eSuccess) {
459 return {};
460 }
461 std::vector<vk::PhysicalDevice> devices(num_devices);
462 if (instance->enumeratePhysicalDevices(&num_devices, devices.data(), dld) !=
463 vk::Result::eSuccess) {
464 return {};
465 }
466
467 std::vector<std::string> names;
468 names.reserve(num_devices);
469 for (auto& device : devices) {
470 names.push_back(device.getProperties(dld).deviceName);
471 }
472 return names;
473}
474
279} // namespace Vulkan 475} // namespace Vulkan
diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.h b/src/video_core/renderer_vulkan/renderer_vulkan.h
index d14384e79..42e253de5 100644
--- a/src/video_core/renderer_vulkan/renderer_vulkan.h
+++ b/src/video_core/renderer_vulkan/renderer_vulkan.h
@@ -6,8 +6,11 @@
6 6
7#include <memory> 7#include <memory>
8#include <optional> 8#include <optional>
9#include <string>
9#include <vector> 10#include <vector>
10 11
12#include "common/dynamic_library.h"
13
11#include "video_core/renderer_base.h" 14#include "video_core/renderer_base.h"
12#include "video_core/renderer_vulkan/declarations.h" 15#include "video_core/renderer_vulkan/declarations.h"
13 16
@@ -44,18 +47,24 @@ public:
44 void SwapBuffers(const Tegra::FramebufferConfig* framebuffer) override; 47 void SwapBuffers(const Tegra::FramebufferConfig* framebuffer) override;
45 bool TryPresent(int timeout_ms) override; 48 bool TryPresent(int timeout_ms) override;
46 49
50 static std::vector<std::string> EnumerateDevices();
51
47private: 52private:
48 std::optional<vk::DebugUtilsMessengerEXT> CreateDebugCallback( 53 bool CreateDebugCallback();
49 const vk::DispatchLoaderDynamic& dldi);
50 54
51 bool PickDevices(const vk::DispatchLoaderDynamic& dldi); 55 bool CreateSurface();
56
57 bool PickDevices();
52 58
53 void Report() const; 59 void Report() const;
54 60
55 Core::System& system; 61 Core::System& system;
56 62
57 vk::Instance instance; 63 Common::DynamicLibrary library;
58 vk::SurfaceKHR surface; 64 vk::DispatchLoaderDynamic dld;
65
66 UniqueInstance instance;
67 UniqueSurfaceKHR surface;
59 68
60 VKScreenInfo screen_info; 69 VKScreenInfo screen_info;
61 70
diff --git a/src/video_core/renderer_vulkan/vk_device.cpp b/src/video_core/renderer_vulkan/vk_device.cpp
index 7aafb5e59..6f4ae9132 100644
--- a/src/video_core/renderer_vulkan/vk_device.cpp
+++ b/src/video_core/renderer_vulkan/vk_device.cpp
@@ -10,6 +10,7 @@
10#include <string_view> 10#include <string_view>
11#include <thread> 11#include <thread>
12#include <vector> 12#include <vector>
13
13#include "common/assert.h" 14#include "common/assert.h"
14#include "core/settings.h" 15#include "core/settings.h"
15#include "video_core/renderer_vulkan/declarations.h" 16#include "video_core/renderer_vulkan/declarations.h"
@@ -35,20 +36,20 @@ void SetNext(void**& next, T& data) {
35} 36}
36 37
37template <typename T> 38template <typename T>
38T GetFeatures(vk::PhysicalDevice physical, const vk::DispatchLoaderDynamic& dldi) { 39T GetFeatures(vk::PhysicalDevice physical, const vk::DispatchLoaderDynamic& dld) {
39 vk::PhysicalDeviceFeatures2 features; 40 vk::PhysicalDeviceFeatures2 features;
40 T extension_features; 41 T extension_features;
41 features.pNext = &extension_features; 42 features.pNext = &extension_features;
42 physical.getFeatures2(&features, dldi); 43 physical.getFeatures2(&features, dld);
43 return extension_features; 44 return extension_features;
44} 45}
45 46
46template <typename T> 47template <typename T>
47T GetProperties(vk::PhysicalDevice physical, const vk::DispatchLoaderDynamic& dldi) { 48T GetProperties(vk::PhysicalDevice physical, const vk::DispatchLoaderDynamic& dld) {
48 vk::PhysicalDeviceProperties2 properties; 49 vk::PhysicalDeviceProperties2 properties;
49 T extension_properties; 50 T extension_properties;
50 properties.pNext = &extension_properties; 51 properties.pNext = &extension_properties;
51 physical.getProperties2(&properties, dldi); 52 physical.getProperties2(&properties, dld);
52 return extension_properties; 53 return extension_properties;
53} 54}
54 55
@@ -78,19 +79,19 @@ vk::FormatFeatureFlags GetFormatFeatures(vk::FormatProperties properties, Format
78 79
79} // Anonymous namespace 80} // Anonymous namespace
80 81
81VKDevice::VKDevice(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice physical, 82VKDevice::VKDevice(const vk::DispatchLoaderDynamic& dld, vk::PhysicalDevice physical,
82 vk::SurfaceKHR surface) 83 vk::SurfaceKHR surface)
83 : physical{physical}, properties{physical.getProperties(dldi)}, 84 : dld{dld}, physical{physical}, properties{physical.getProperties(dld)},
84 format_properties{GetFormatProperties(dldi, physical)} { 85 format_properties{GetFormatProperties(dld, physical)} {
85 SetupFamilies(dldi, surface); 86 SetupFamilies(surface);
86 SetupFeatures(dldi); 87 SetupFeatures();
87} 88}
88 89
89VKDevice::~VKDevice() = default; 90VKDevice::~VKDevice() = default;
90 91
91bool VKDevice::Create(const vk::DispatchLoaderDynamic& dldi, vk::Instance instance) { 92bool VKDevice::Create(vk::Instance instance) {
92 const auto queue_cis = GetDeviceQueueCreateInfos(); 93 const auto queue_cis = GetDeviceQueueCreateInfos();
93 const std::vector extensions = LoadExtensions(dldi); 94 const std::vector extensions = LoadExtensions();
94 95
95 vk::PhysicalDeviceFeatures2 features2; 96 vk::PhysicalDeviceFeatures2 features2;
96 void** next = &features2.pNext; 97 void** next = &features2.pNext;
@@ -165,15 +166,13 @@ bool VKDevice::Create(const vk::DispatchLoaderDynamic& dldi, vk::Instance instan
165 nullptr); 166 nullptr);
166 device_ci.pNext = &features2; 167 device_ci.pNext = &features2;
167 168
168 vk::Device dummy_logical; 169 vk::Device unsafe_logical;
169 if (physical.createDevice(&device_ci, nullptr, &dummy_logical, dldi) != vk::Result::eSuccess) { 170 if (physical.createDevice(&device_ci, nullptr, &unsafe_logical, dld) != vk::Result::eSuccess) {
170 LOG_CRITICAL(Render_Vulkan, "Logical device failed to be created!"); 171 LOG_CRITICAL(Render_Vulkan, "Logical device failed to be created!");
171 return false; 172 return false;
172 } 173 }
173 174 dld.init(instance, dld.vkGetInstanceProcAddr, unsafe_logical);
174 dld.init(instance, dldi.vkGetInstanceProcAddr, dummy_logical, dldi.vkGetDeviceProcAddr); 175 logical = UniqueDevice(unsafe_logical, {nullptr, dld});
175 logical = UniqueDevice(
176 dummy_logical, vk::ObjectDestroy<vk::NoParent, vk::DispatchLoaderDynamic>(nullptr, dld));
177 176
178 CollectTelemetryParameters(); 177 CollectTelemetryParameters();
179 178
@@ -235,8 +234,8 @@ void VKDevice::ReportLoss() const {
235 // *(VKGraphicsPipeline*)data[0] 234 // *(VKGraphicsPipeline*)data[0]
236} 235}
237 236
238bool VKDevice::IsOptimalAstcSupported(const vk::PhysicalDeviceFeatures& features, 237bool VKDevice::IsOptimalAstcSupported(const vk::PhysicalDeviceFeatures& features) const {
239 const vk::DispatchLoaderDynamic& dldi) const { 238 // Disable for now to avoid converting ASTC twice.
240 static constexpr std::array astc_formats = { 239 static constexpr std::array astc_formats = {
241 vk::Format::eAstc4x4UnormBlock, vk::Format::eAstc4x4SrgbBlock, 240 vk::Format::eAstc4x4UnormBlock, vk::Format::eAstc4x4SrgbBlock,
242 vk::Format::eAstc5x4UnormBlock, vk::Format::eAstc5x4SrgbBlock, 241 vk::Format::eAstc5x4UnormBlock, vk::Format::eAstc5x4SrgbBlock,
@@ -260,7 +259,7 @@ bool VKDevice::IsOptimalAstcSupported(const vk::PhysicalDeviceFeatures& features
260 vk::FormatFeatureFlagBits::eBlitDst | vk::FormatFeatureFlagBits::eTransferSrc | 259 vk::FormatFeatureFlagBits::eBlitDst | vk::FormatFeatureFlagBits::eTransferSrc |
261 vk::FormatFeatureFlagBits::eTransferDst}; 260 vk::FormatFeatureFlagBits::eTransferDst};
262 for (const auto format : astc_formats) { 261 for (const auto format : astc_formats) {
263 const auto format_properties{physical.getFormatProperties(format, dldi)}; 262 const auto format_properties{physical.getFormatProperties(format, dld)};
264 if (!(format_properties.optimalTilingFeatures & format_feature_usage)) { 263 if (!(format_properties.optimalTilingFeatures & format_feature_usage)) {
265 return false; 264 return false;
266 } 265 }
@@ -279,11 +278,9 @@ bool VKDevice::IsFormatSupported(vk::Format wanted_format, vk::FormatFeatureFlag
279 return (supported_usage & wanted_usage) == wanted_usage; 278 return (supported_usage & wanted_usage) == wanted_usage;
280} 279}
281 280
282bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice physical, 281bool VKDevice::IsSuitable(vk::PhysicalDevice physical, vk::SurfaceKHR surface,
283 vk::SurfaceKHR surface) { 282 const vk::DispatchLoaderDynamic& dld) {
284 bool is_suitable = true; 283 static constexpr std::array required_extensions = {
285
286 constexpr std::array required_extensions = {
287 VK_KHR_SWAPCHAIN_EXTENSION_NAME, 284 VK_KHR_SWAPCHAIN_EXTENSION_NAME,
288 VK_KHR_16BIT_STORAGE_EXTENSION_NAME, 285 VK_KHR_16BIT_STORAGE_EXTENSION_NAME,
289 VK_KHR_8BIT_STORAGE_EXTENSION_NAME, 286 VK_KHR_8BIT_STORAGE_EXTENSION_NAME,
@@ -293,9 +290,10 @@ bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDev
293 VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME, 290 VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME,
294 VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, 291 VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME,
295 }; 292 };
293 bool is_suitable = true;
296 std::bitset<required_extensions.size()> available_extensions{}; 294 std::bitset<required_extensions.size()> available_extensions{};
297 295
298 for (const auto& prop : physical.enumerateDeviceExtensionProperties(nullptr, dldi)) { 296 for (const auto& prop : physical.enumerateDeviceExtensionProperties(nullptr, dld)) {
299 for (std::size_t i = 0; i < required_extensions.size(); ++i) { 297 for (std::size_t i = 0; i < required_extensions.size(); ++i) {
300 if (available_extensions[i]) { 298 if (available_extensions[i]) {
301 continue; 299 continue;
@@ -315,7 +313,7 @@ bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDev
315 } 313 }
316 314
317 bool has_graphics{}, has_present{}; 315 bool has_graphics{}, has_present{};
318 const auto queue_family_properties = physical.getQueueFamilyProperties(dldi); 316 const auto queue_family_properties = physical.getQueueFamilyProperties(dld);
319 for (u32 i = 0; i < static_cast<u32>(queue_family_properties.size()); ++i) { 317 for (u32 i = 0; i < static_cast<u32>(queue_family_properties.size()); ++i) {
320 const auto& family = queue_family_properties[i]; 318 const auto& family = queue_family_properties[i];
321 if (family.queueCount == 0) { 319 if (family.queueCount == 0) {
@@ -323,7 +321,7 @@ bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDev
323 } 321 }
324 has_graphics |= 322 has_graphics |=
325 (family.queueFlags & vk::QueueFlagBits::eGraphics) != static_cast<vk::QueueFlagBits>(0); 323 (family.queueFlags & vk::QueueFlagBits::eGraphics) != static_cast<vk::QueueFlagBits>(0);
326 has_present |= physical.getSurfaceSupportKHR(i, surface, dldi) != 0; 324 has_present |= physical.getSurfaceSupportKHR(i, surface, dld) != 0;
327 } 325 }
328 if (!has_graphics || !has_present) { 326 if (!has_graphics || !has_present) {
329 LOG_ERROR(Render_Vulkan, "Device lacks a graphics and present queue"); 327 LOG_ERROR(Render_Vulkan, "Device lacks a graphics and present queue");
@@ -331,7 +329,7 @@ bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDev
331 } 329 }
332 330
333 // TODO(Rodrigo): Check if the device matches all requeriments. 331 // TODO(Rodrigo): Check if the device matches all requeriments.
334 const auto properties{physical.getProperties(dldi)}; 332 const auto properties{physical.getProperties(dld)};
335 const auto& limits{properties.limits}; 333 const auto& limits{properties.limits};
336 334
337 constexpr u32 required_ubo_size = 65536; 335 constexpr u32 required_ubo_size = 65536;
@@ -348,7 +346,7 @@ bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDev
348 is_suitable = false; 346 is_suitable = false;
349 } 347 }
350 348
351 const auto features{physical.getFeatures(dldi)}; 349 const auto features{physical.getFeatures(dld)};
352 const std::array feature_report = { 350 const std::array feature_report = {
353 std::make_pair(features.vertexPipelineStoresAndAtomics, "vertexPipelineStoresAndAtomics"), 351 std::make_pair(features.vertexPipelineStoresAndAtomics, "vertexPipelineStoresAndAtomics"),
354 std::make_pair(features.independentBlend, "independentBlend"), 352 std::make_pair(features.independentBlend, "independentBlend"),
@@ -380,7 +378,7 @@ bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDev
380 return is_suitable; 378 return is_suitable;
381} 379}
382 380
383std::vector<const char*> VKDevice::LoadExtensions(const vk::DispatchLoaderDynamic& dldi) { 381std::vector<const char*> VKDevice::LoadExtensions() {
384 std::vector<const char*> extensions; 382 std::vector<const char*> extensions;
385 const auto Test = [&](const vk::ExtensionProperties& extension, 383 const auto Test = [&](const vk::ExtensionProperties& extension,
386 std::optional<std::reference_wrapper<bool>> status, const char* name, 384 std::optional<std::reference_wrapper<bool>> status, const char* name,
@@ -411,7 +409,7 @@ std::vector<const char*> VKDevice::LoadExtensions(const vk::DispatchLoaderDynami
411 bool has_khr_shader_float16_int8{}; 409 bool has_khr_shader_float16_int8{};
412 bool has_ext_subgroup_size_control{}; 410 bool has_ext_subgroup_size_control{};
413 bool has_ext_transform_feedback{}; 411 bool has_ext_transform_feedback{};
414 for (const auto& extension : physical.enumerateDeviceExtensionProperties(nullptr, dldi)) { 412 for (const auto& extension : physical.enumerateDeviceExtensionProperties(nullptr, dld)) {
415 Test(extension, khr_uniform_buffer_standard_layout, 413 Test(extension, khr_uniform_buffer_standard_layout,
416 VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, true); 414 VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, true);
417 Test(extension, has_khr_shader_float16_int8, VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, 415 Test(extension, has_khr_shader_float16_int8, VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME,
@@ -433,15 +431,15 @@ std::vector<const char*> VKDevice::LoadExtensions(const vk::DispatchLoaderDynami
433 431
434 if (has_khr_shader_float16_int8) { 432 if (has_khr_shader_float16_int8) {
435 is_float16_supported = 433 is_float16_supported =
436 GetFeatures<vk::PhysicalDeviceFloat16Int8FeaturesKHR>(physical, dldi).shaderFloat16; 434 GetFeatures<vk::PhysicalDeviceFloat16Int8FeaturesKHR>(physical, dld).shaderFloat16;
437 extensions.push_back(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME); 435 extensions.push_back(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME);
438 } 436 }
439 437
440 if (has_ext_subgroup_size_control) { 438 if (has_ext_subgroup_size_control) {
441 const auto features = 439 const auto features =
442 GetFeatures<vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT>(physical, dldi); 440 GetFeatures<vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT>(physical, dld);
443 const auto properties = 441 const auto properties =
444 GetProperties<vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT>(physical, dldi); 442 GetProperties<vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT>(physical, dld);
445 443
446 is_warp_potentially_bigger = properties.maxSubgroupSize > GuestWarpSize; 444 is_warp_potentially_bigger = properties.maxSubgroupSize > GuestWarpSize;
447 445
@@ -456,9 +454,9 @@ std::vector<const char*> VKDevice::LoadExtensions(const vk::DispatchLoaderDynami
456 454
457 if (has_ext_transform_feedback) { 455 if (has_ext_transform_feedback) {
458 const auto features = 456 const auto features =
459 GetFeatures<vk::PhysicalDeviceTransformFeedbackFeaturesEXT>(physical, dldi); 457 GetFeatures<vk::PhysicalDeviceTransformFeedbackFeaturesEXT>(physical, dld);
460 const auto properties = 458 const auto properties =
461 GetProperties<vk::PhysicalDeviceTransformFeedbackPropertiesEXT>(physical, dldi); 459 GetProperties<vk::PhysicalDeviceTransformFeedbackPropertiesEXT>(physical, dld);
462 460
463 if (features.transformFeedback && features.geometryStreams && 461 if (features.transformFeedback && features.geometryStreams &&
464 properties.maxTransformFeedbackStreams >= 4 && properties.maxTransformFeedbackBuffers && 462 properties.maxTransformFeedbackStreams >= 4 && properties.maxTransformFeedbackBuffers &&
@@ -471,10 +469,10 @@ std::vector<const char*> VKDevice::LoadExtensions(const vk::DispatchLoaderDynami
471 return extensions; 469 return extensions;
472} 470}
473 471
474void VKDevice::SetupFamilies(const vk::DispatchLoaderDynamic& dldi, vk::SurfaceKHR surface) { 472void VKDevice::SetupFamilies(vk::SurfaceKHR surface) {
475 std::optional<u32> graphics_family_, present_family_; 473 std::optional<u32> graphics_family_, present_family_;
476 474
477 const auto queue_family_properties = physical.getQueueFamilyProperties(dldi); 475 const auto queue_family_properties = physical.getQueueFamilyProperties(dld);
478 for (u32 i = 0; i < static_cast<u32>(queue_family_properties.size()); ++i) { 476 for (u32 i = 0; i < static_cast<u32>(queue_family_properties.size()); ++i) {
479 if (graphics_family_ && present_family_) 477 if (graphics_family_ && present_family_)
480 break; 478 break;
@@ -483,10 +481,12 @@ void VKDevice::SetupFamilies(const vk::DispatchLoaderDynamic& dldi, vk::SurfaceK
483 if (queue_family.queueCount == 0) 481 if (queue_family.queueCount == 0)
484 continue; 482 continue;
485 483
486 if (queue_family.queueFlags & vk::QueueFlagBits::eGraphics) 484 if (queue_family.queueFlags & vk::QueueFlagBits::eGraphics) {
487 graphics_family_ = i; 485 graphics_family_ = i;
488 if (physical.getSurfaceSupportKHR(i, surface, dldi)) 486 }
487 if (physical.getSurfaceSupportKHR(i, surface, dld)) {
489 present_family_ = i; 488 present_family_ = i;
489 }
490 } 490 }
491 ASSERT(graphics_family_ && present_family_); 491 ASSERT(graphics_family_ && present_family_);
492 492
@@ -494,10 +494,10 @@ void VKDevice::SetupFamilies(const vk::DispatchLoaderDynamic& dldi, vk::SurfaceK
494 present_family = *present_family_; 494 present_family = *present_family_;
495} 495}
496 496
497void VKDevice::SetupFeatures(const vk::DispatchLoaderDynamic& dldi) { 497void VKDevice::SetupFeatures() {
498 const auto supported_features{physical.getFeatures(dldi)}; 498 const auto supported_features{physical.getFeatures(dld)};
499 is_formatless_image_load_supported = supported_features.shaderStorageImageReadWithoutFormat; 499 is_formatless_image_load_supported = supported_features.shaderStorageImageReadWithoutFormat;
500 is_optimal_astc_supported = IsOptimalAstcSupported(supported_features, dldi); 500 is_optimal_astc_supported = IsOptimalAstcSupported(supported_features);
501} 501}
502 502
503void VKDevice::CollectTelemetryParameters() { 503void VKDevice::CollectTelemetryParameters() {
@@ -525,7 +525,7 @@ std::vector<vk::DeviceQueueCreateInfo> VKDevice::GetDeviceQueueCreateInfos() con
525} 525}
526 526
527std::unordered_map<vk::Format, vk::FormatProperties> VKDevice::GetFormatProperties( 527std::unordered_map<vk::Format, vk::FormatProperties> VKDevice::GetFormatProperties(
528 const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice physical) { 528 const vk::DispatchLoaderDynamic& dld, vk::PhysicalDevice physical) {
529 static constexpr std::array formats{vk::Format::eA8B8G8R8UnormPack32, 529 static constexpr std::array formats{vk::Format::eA8B8G8R8UnormPack32,
530 vk::Format::eA8B8G8R8UintPack32, 530 vk::Format::eA8B8G8R8UintPack32,
531 vk::Format::eA8B8G8R8SnormPack32, 531 vk::Format::eA8B8G8R8SnormPack32,
@@ -606,7 +606,7 @@ std::unordered_map<vk::Format, vk::FormatProperties> VKDevice::GetFormatProperti
606 vk::Format::eE5B9G9R9UfloatPack32}; 606 vk::Format::eE5B9G9R9UfloatPack32};
607 std::unordered_map<vk::Format, vk::FormatProperties> format_properties; 607 std::unordered_map<vk::Format, vk::FormatProperties> format_properties;
608 for (const auto format : formats) { 608 for (const auto format : formats) {
609 format_properties.emplace(format, physical.getFormatProperties(format, dldi)); 609 format_properties.emplace(format, physical.getFormatProperties(format, dld));
610 } 610 }
611 return format_properties; 611 return format_properties;
612} 612}
diff --git a/src/video_core/renderer_vulkan/vk_device.h b/src/video_core/renderer_vulkan/vk_device.h
index 6e656517f..d9d809852 100644
--- a/src/video_core/renderer_vulkan/vk_device.h
+++ b/src/video_core/renderer_vulkan/vk_device.h
@@ -22,12 +22,12 @@ const u32 GuestWarpSize = 32;
22/// Handles data specific to a physical device. 22/// Handles data specific to a physical device.
23class VKDevice final { 23class VKDevice final {
24public: 24public:
25 explicit VKDevice(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice physical, 25 explicit VKDevice(const vk::DispatchLoaderDynamic& dld, vk::PhysicalDevice physical,
26 vk::SurfaceKHR surface); 26 vk::SurfaceKHR surface);
27 ~VKDevice(); 27 ~VKDevice();
28 28
29 /// Initializes the device. Returns true on success. 29 /// Initializes the device. Returns true on success.
30 bool Create(const vk::DispatchLoaderDynamic& dldi, vk::Instance instance); 30 bool Create(vk::Instance instance);
31 31
32 /** 32 /**
33 * Returns a format supported by the device for the passed requeriments. 33 * Returns a format supported by the device for the passed requeriments.
@@ -188,18 +188,18 @@ public:
188 } 188 }
189 189
190 /// Checks if the physical device is suitable. 190 /// Checks if the physical device is suitable.
191 static bool IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice physical, 191 static bool IsSuitable(vk::PhysicalDevice physical, vk::SurfaceKHR surface,
192 vk::SurfaceKHR surface); 192 const vk::DispatchLoaderDynamic& dld);
193 193
194private: 194private:
195 /// Loads extensions into a vector and stores available ones in this object. 195 /// Loads extensions into a vector and stores available ones in this object.
196 std::vector<const char*> LoadExtensions(const vk::DispatchLoaderDynamic& dldi); 196 std::vector<const char*> LoadExtensions();
197 197
198 /// Sets up queue families. 198 /// Sets up queue families.
199 void SetupFamilies(const vk::DispatchLoaderDynamic& dldi, vk::SurfaceKHR surface); 199 void SetupFamilies(vk::SurfaceKHR surface);
200 200
201 /// Sets up device features. 201 /// Sets up device features.
202 void SetupFeatures(const vk::DispatchLoaderDynamic& dldi); 202 void SetupFeatures();
203 203
204 /// Collects telemetry information from the device. 204 /// Collects telemetry information from the device.
205 void CollectTelemetryParameters(); 205 void CollectTelemetryParameters();
@@ -208,8 +208,7 @@ private:
208 std::vector<vk::DeviceQueueCreateInfo> GetDeviceQueueCreateInfos() const; 208 std::vector<vk::DeviceQueueCreateInfo> GetDeviceQueueCreateInfos() const;
209 209
210 /// Returns true if ASTC textures are natively supported. 210 /// Returns true if ASTC textures are natively supported.
211 bool IsOptimalAstcSupported(const vk::PhysicalDeviceFeatures& features, 211 bool IsOptimalAstcSupported(const vk::PhysicalDeviceFeatures& features) const;
212 const vk::DispatchLoaderDynamic& dldi) const;
213 212
214 /// Returns true if a format is supported. 213 /// Returns true if a format is supported.
215 bool IsFormatSupported(vk::Format wanted_format, vk::FormatFeatureFlags wanted_usage, 214 bool IsFormatSupported(vk::Format wanted_format, vk::FormatFeatureFlags wanted_usage,
@@ -217,10 +216,10 @@ private:
217 216
218 /// Returns the device properties for Vulkan formats. 217 /// Returns the device properties for Vulkan formats.
219 static std::unordered_map<vk::Format, vk::FormatProperties> GetFormatProperties( 218 static std::unordered_map<vk::Format, vk::FormatProperties> GetFormatProperties(
220 const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice physical); 219 const vk::DispatchLoaderDynamic& dld, vk::PhysicalDevice physical);
221 220
222 const vk::PhysicalDevice physical; ///< Physical device.
223 vk::DispatchLoaderDynamic dld; ///< Device function pointers. 221 vk::DispatchLoaderDynamic dld; ///< Device function pointers.
222 vk::PhysicalDevice physical; ///< Physical device.
224 vk::PhysicalDeviceProperties properties; ///< Device properties. 223 vk::PhysicalDeviceProperties properties; ///< Device properties.
225 UniqueDevice logical; ///< Logical device. 224 UniqueDevice logical; ///< Logical device.
226 vk::Queue graphics_queue; ///< Main graphics queue. 225 vk::Queue graphics_queue; ///< Main graphics queue.
diff --git a/src/video_core/shader/decode/video.cpp b/src/video_core/shader/decode/video.cpp
index b047cf870..64ba60ea2 100644
--- a/src/video_core/shader/decode/video.cpp
+++ b/src/video_core/shader/decode/video.cpp
@@ -10,16 +10,24 @@
10 10
11namespace VideoCommon::Shader { 11namespace VideoCommon::Shader {
12 12
13using std::move;
13using Tegra::Shader::Instruction; 14using Tegra::Shader::Instruction;
14using Tegra::Shader::OpCode; 15using Tegra::Shader::OpCode;
15using Tegra::Shader::Pred; 16using Tegra::Shader::Pred;
16using Tegra::Shader::VideoType; 17using Tegra::Shader::VideoType;
17using Tegra::Shader::VmadShr; 18using Tegra::Shader::VmadShr;
19using Tegra::Shader::VmnmxOperation;
20using Tegra::Shader::VmnmxType;
18 21
19u32 ShaderIR::DecodeVideo(NodeBlock& bb, u32 pc) { 22u32 ShaderIR::DecodeVideo(NodeBlock& bb, u32 pc) {
20 const Instruction instr = {program_code[pc]}; 23 const Instruction instr = {program_code[pc]};
21 const auto opcode = OpCode::Decode(instr); 24 const auto opcode = OpCode::Decode(instr);
22 25
26 if (opcode->get().GetId() == OpCode::Id::VMNMX) {
27 DecodeVMNMX(bb, instr);
28 return pc;
29 }
30
23 const Node op_a = 31 const Node op_a =
24 GetVideoOperand(GetRegister(instr.gpr8), instr.video.is_byte_chunk_a, instr.video.signed_a, 32 GetVideoOperand(GetRegister(instr.gpr8), instr.video.is_byte_chunk_a, instr.video.signed_a,
25 instr.video.type_a, instr.video.byte_height_a); 33 instr.video.type_a, instr.video.byte_height_a);
@@ -109,4 +117,54 @@ Node ShaderIR::GetVideoOperand(Node op, bool is_chunk, bool is_signed,
109 } 117 }
110} 118}
111 119
120void ShaderIR::DecodeVMNMX(NodeBlock& bb, Tegra::Shader::Instruction instr) {
121 UNIMPLEMENTED_IF(!instr.vmnmx.is_op_b_register);
122 UNIMPLEMENTED_IF(instr.vmnmx.SourceFormatA() != VmnmxType::Bits32);
123 UNIMPLEMENTED_IF(instr.vmnmx.SourceFormatB() != VmnmxType::Bits32);
124 UNIMPLEMENTED_IF(instr.vmnmx.is_src_a_signed != instr.vmnmx.is_src_b_signed);
125 UNIMPLEMENTED_IF(instr.vmnmx.sat);
126 UNIMPLEMENTED_IF(instr.generates_cc);
127
128 Node op_a = GetRegister(instr.gpr8);
129 Node op_b = GetRegister(instr.gpr20);
130 Node op_c = GetRegister(instr.gpr39);
131
132 const bool is_oper1_signed = instr.vmnmx.is_src_a_signed; // Stubbed
133 const bool is_oper2_signed = instr.vmnmx.is_dest_signed;
134
135 const auto operation_a = instr.vmnmx.mx ? OperationCode::IMax : OperationCode::IMin;
136 Node value = SignedOperation(operation_a, is_oper1_signed, move(op_a), move(op_b));
137
138 switch (instr.vmnmx.operation) {
139 case VmnmxOperation::Mrg_16H:
140 value = BitfieldInsert(move(op_c), move(value), 16, 16);
141 break;
142 case VmnmxOperation::Mrg_16L:
143 value = BitfieldInsert(move(op_c), move(value), 0, 16);
144 break;
145 case VmnmxOperation::Mrg_8B0:
146 value = BitfieldInsert(move(op_c), move(value), 0, 8);
147 break;
148 case VmnmxOperation::Mrg_8B2:
149 value = BitfieldInsert(move(op_c), move(value), 16, 8);
150 break;
151 case VmnmxOperation::Acc:
152 value = Operation(OperationCode::IAdd, move(value), move(op_c));
153 break;
154 case VmnmxOperation::Min:
155 value = SignedOperation(OperationCode::IMin, is_oper2_signed, move(value), move(op_c));
156 break;
157 case VmnmxOperation::Max:
158 value = SignedOperation(OperationCode::IMax, is_oper2_signed, move(value), move(op_c));
159 break;
160 case VmnmxOperation::Nop:
161 break;
162 default:
163 UNREACHABLE();
164 break;
165 }
166
167 SetRegister(bb, instr.gpr0, move(value));
168}
169
112} // namespace VideoCommon::Shader 170} // namespace VideoCommon::Shader
diff --git a/src/video_core/shader/shader_ir.h b/src/video_core/shader/shader_ir.h
index ca6c976c9..c6e7bdf50 100644
--- a/src/video_core/shader/shader_ir.h
+++ b/src/video_core/shader/shader_ir.h
@@ -354,6 +354,9 @@ private:
354 /// Marks the usage of a input or output attribute. 354 /// Marks the usage of a input or output attribute.
355 void MarkAttributeUsage(Tegra::Shader::Attribute::Index index, u64 element); 355 void MarkAttributeUsage(Tegra::Shader::Attribute::Index index, u64 element);
356 356
357 /// Decodes VMNMX instruction and inserts its code into the passed basic block.
358 void DecodeVMNMX(NodeBlock& bb, Tegra::Shader::Instruction instr);
359
357 void WriteTexInstructionFloat(NodeBlock& bb, Tegra::Shader::Instruction instr, 360 void WriteTexInstructionFloat(NodeBlock& bb, Tegra::Shader::Instruction instr,
358 const Node4& components); 361 const Node4& components);
359 362
diff --git a/src/video_core/textures/texture.h b/src/video_core/textures/texture.h
index 59b8a5e66..eba05aced 100644
--- a/src/video_core/textures/texture.h
+++ b/src/video_core/textures/texture.h
@@ -131,6 +131,20 @@ enum class SwizzleSource : u32 {
131 OneFloat = 7, 131 OneFloat = 7,
132}; 132};
133 133
134enum class MsaaMode : u32 {
135 Msaa1x1 = 0,
136 Msaa2x1 = 1,
137 Msaa2x2 = 2,
138 Msaa4x2 = 3,
139 Msaa4x2_D3D = 4,
140 Msaa2x1_D3D = 5,
141 Msaa4x4 = 6,
142 Msaa2x2_VC4 = 8,
143 Msaa2x2_VC12 = 9,
144 Msaa4x2_VC8 = 10,
145 Msaa4x2_VC24 = 11,
146};
147
134union TextureHandle { 148union TextureHandle {
135 TextureHandle(u32 raw) : raw{raw} {} 149 TextureHandle(u32 raw) : raw{raw} {}
136 150
@@ -197,6 +211,7 @@ struct TICEntry {
197 union { 211 union {
198 BitField<0, 4, u32> res_min_mip_level; 212 BitField<0, 4, u32> res_min_mip_level;
199 BitField<4, 4, u32> res_max_mip_level; 213 BitField<4, 4, u32> res_max_mip_level;
214 BitField<8, 4, MsaaMode> msaa_mode;
200 BitField<12, 12, u32> min_lod_clamp; 215 BitField<12, 12, u32> min_lod_clamp;
201 }; 216 };
202 217
diff --git a/src/yuzu/CMakeLists.txt b/src/yuzu/CMakeLists.txt
index d34b47b3f..8b9404718 100644
--- a/src/yuzu/CMakeLists.txt
+++ b/src/yuzu/CMakeLists.txt
@@ -150,6 +150,10 @@ target_link_libraries(yuzu PRIVATE common core input_common video_core)
150target_link_libraries(yuzu PRIVATE Boost::boost glad Qt5::OpenGL Qt5::Widgets) 150target_link_libraries(yuzu PRIVATE Boost::boost glad Qt5::OpenGL Qt5::Widgets)
151target_link_libraries(yuzu PRIVATE ${PLATFORM_LIBRARIES} Threads::Threads) 151target_link_libraries(yuzu PRIVATE ${PLATFORM_LIBRARIES} Threads::Threads)
152 152
153if (ENABLE_VULKAN AND NOT WIN32)
154 target_include_directories(yuzu PRIVATE ${Qt5Gui_PRIVATE_INCLUDE_DIRS})
155endif()
156
153target_compile_definitions(yuzu PRIVATE 157target_compile_definitions(yuzu PRIVATE
154 # Use QStringBuilder for string concatenation to reduce 158 # Use QStringBuilder for string concatenation to reduce
155 # the overall number of temporary strings created. 159 # the overall number of temporary strings created.
diff --git a/src/yuzu/bootmanager.cpp b/src/yuzu/bootmanager.cpp
index 7b211bd32..1cac2f942 100644
--- a/src/yuzu/bootmanager.cpp
+++ b/src/yuzu/bootmanager.cpp
@@ -14,8 +14,9 @@
14#include <QScreen> 14#include <QScreen>
15#include <QStringList> 15#include <QStringList>
16#include <QWindow> 16#include <QWindow>
17#ifdef HAS_VULKAN 17
18#include <QVulkanWindow> 18#if !defined(WIN32) && HAS_VULKAN
19#include <qpa/qplatformnativeinterface.h>
19#endif 20#endif
20 21
21#include <fmt/format.h> 22#include <fmt/format.h>
@@ -237,16 +238,50 @@ private:
237#ifdef HAS_VULKAN 238#ifdef HAS_VULKAN
238class VulkanRenderWidget : public RenderWidget { 239class VulkanRenderWidget : public RenderWidget {
239public: 240public:
240 explicit VulkanRenderWidget(GRenderWindow* parent, QVulkanInstance* instance) 241 explicit VulkanRenderWidget(GRenderWindow* parent) : RenderWidget(parent) {
241 : RenderWidget(parent) {
242 windowHandle()->setSurfaceType(QWindow::VulkanSurface); 242 windowHandle()->setSurfaceType(QWindow::VulkanSurface);
243 windowHandle()->setVulkanInstance(instance);
244 } 243 }
245}; 244};
246#endif 245#endif
247 246
248GRenderWindow::GRenderWindow(GMainWindow* parent_, EmuThread* emu_thread) 247static Core::Frontend::WindowSystemType GetWindowSystemType() {
249 : QWidget(parent_), emu_thread(emu_thread) { 248 // Determine WSI type based on Qt platform.
249 QString platform_name = QGuiApplication::platformName();
250 if (platform_name == QStringLiteral("windows"))
251 return Core::Frontend::WindowSystemType::Windows;
252 else if (platform_name == QStringLiteral("xcb"))
253 return Core::Frontend::WindowSystemType::X11;
254 else if (platform_name == QStringLiteral("wayland"))
255 return Core::Frontend::WindowSystemType::Wayland;
256
257 LOG_CRITICAL(Frontend, "Unknown Qt platform!");
258 return Core::Frontend::WindowSystemType::Windows;
259}
260
261static Core::Frontend::EmuWindow::WindowSystemInfo GetWindowSystemInfo(QWindow* window) {
262 Core::Frontend::EmuWindow::WindowSystemInfo wsi;
263 wsi.type = GetWindowSystemType();
264
265#ifdef HAS_VULKAN
266 // Our Win32 Qt external doesn't have the private API.
267#if defined(WIN32) || defined(__APPLE__)
268 wsi.render_surface = window ? reinterpret_cast<void*>(window->winId()) : nullptr;
269#else
270 QPlatformNativeInterface* pni = QGuiApplication::platformNativeInterface();
271 wsi.display_connection = pni->nativeResourceForWindow("display", window);
272 if (wsi.type == Core::Frontend::WindowSystemType::Wayland)
273 wsi.render_surface = window ? pni->nativeResourceForWindow("surface", window) : nullptr;
274 else
275 wsi.render_surface = window ? reinterpret_cast<void*>(window->winId()) : nullptr;
276#endif
277 wsi.render_surface_scale = window ? static_cast<float>(window->devicePixelRatio()) : 1.0f;
278#endif
279
280 return wsi;
281}
282
283GRenderWindow::GRenderWindow(GMainWindow* parent_, EmuThread* emu_thread_)
284 : QWidget(parent_), emu_thread(emu_thread_) {
250 setWindowTitle(QStringLiteral("yuzu %1 | %2-%3") 285 setWindowTitle(QStringLiteral("yuzu %1 | %2-%3")
251 .arg(QString::fromUtf8(Common::g_build_name), 286 .arg(QString::fromUtf8(Common::g_build_name),
252 QString::fromUtf8(Common::g_scm_branch), 287 QString::fromUtf8(Common::g_scm_branch),
@@ -459,6 +494,9 @@ bool GRenderWindow::InitRenderTarget() {
459 break; 494 break;
460 } 495 }
461 496
497 // Update the Window System information with the new render target
498 window_info = GetWindowSystemInfo(child_widget->windowHandle());
499
462 child_widget->resize(Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height); 500 child_widget->resize(Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height);
463 layout()->addWidget(child_widget); 501 layout()->addWidget(child_widget);
464 // Reset minimum required size to avoid resizing issues on the main window after restarting. 502 // Reset minimum required size to avoid resizing issues on the main window after restarting.
@@ -530,30 +568,7 @@ bool GRenderWindow::InitializeOpenGL() {
530 568
531bool GRenderWindow::InitializeVulkan() { 569bool GRenderWindow::InitializeVulkan() {
532#ifdef HAS_VULKAN 570#ifdef HAS_VULKAN
533 vk_instance = std::make_unique<QVulkanInstance>(); 571 auto child = new VulkanRenderWidget(this);
534 vk_instance->setApiVersion(QVersionNumber(1, 1, 0));
535 vk_instance->setFlags(QVulkanInstance::Flag::NoDebugOutputRedirect);
536 if (Settings::values.renderer_debug) {
537 const auto supported_layers{vk_instance->supportedLayers()};
538 const bool found =
539 std::find_if(supported_layers.begin(), supported_layers.end(), [](const auto& layer) {
540 constexpr const char searched_layer[] = "VK_LAYER_LUNARG_standard_validation";
541 return layer.name == searched_layer;
542 });
543 if (found) {
544 vk_instance->setLayers(QByteArrayList() << "VK_LAYER_LUNARG_standard_validation");
545 vk_instance->setExtensions(QByteArrayList() << VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
546 }
547 }
548 if (!vk_instance->create()) {
549 QMessageBox::critical(
550 this, tr("Error while initializing Vulkan 1.1!"),
551 tr("Your OS doesn't seem to support Vulkan 1.1 instances, or you do not have the "
552 "latest graphics drivers."));
553 return false;
554 }
555
556 auto child = new VulkanRenderWidget(this, vk_instance.get());
557 child_widget = child; 572 child_widget = child;
558 child_widget->windowHandle()->create(); 573 child_widget->windowHandle()->create();
559 main_context = std::make_unique<DummyContext>(); 574 main_context = std::make_unique<DummyContext>();
@@ -566,21 +581,6 @@ bool GRenderWindow::InitializeVulkan() {
566#endif 581#endif
567} 582}
568 583
569void GRenderWindow::RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
570 void* surface) const {
571#ifdef HAS_VULKAN
572 const auto instance_proc_addr = vk_instance->getInstanceProcAddr("vkGetInstanceProcAddr");
573 const VkInstance instance_copy = vk_instance->vkInstance();
574 const VkSurfaceKHR surface_copy = vk_instance->surfaceForWindow(child_widget->windowHandle());
575
576 std::memcpy(get_instance_proc_addr, &instance_proc_addr, sizeof(instance_proc_addr));
577 std::memcpy(instance, &instance_copy, sizeof(instance_copy));
578 std::memcpy(surface, &surface_copy, sizeof(surface_copy));
579#else
580 UNREACHABLE_MSG("Executing Vulkan code without compiling Vulkan");
581#endif
582}
583
584bool GRenderWindow::LoadOpenGL() { 584bool GRenderWindow::LoadOpenGL() {
585 auto context = CreateSharedContext(); 585 auto context = CreateSharedContext();
586 auto scope = context->Acquire(); 586 auto scope = context->Acquire();
diff --git a/src/yuzu/bootmanager.h b/src/yuzu/bootmanager.h
index d69078df1..3626604ca 100644
--- a/src/yuzu/bootmanager.h
+++ b/src/yuzu/bootmanager.h
@@ -22,9 +22,6 @@ class GMainWindow;
22class QKeyEvent; 22class QKeyEvent;
23class QTouchEvent; 23class QTouchEvent;
24class QStringList; 24class QStringList;
25#ifdef HAS_VULKAN
26class QVulkanInstance;
27#endif
28 25
29namespace VideoCore { 26namespace VideoCore {
30enum class LoadCallbackStage; 27enum class LoadCallbackStage;
@@ -122,8 +119,6 @@ public:
122 // EmuWindow implementation. 119 // EmuWindow implementation.
123 void PollEvents() override; 120 void PollEvents() override;
124 bool IsShown() const override; 121 bool IsShown() const override;
125 void RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
126 void* surface) const override;
127 std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override; 122 std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override;
128 123
129 void BackupGeometry(); 124 void BackupGeometry();
@@ -186,10 +181,6 @@ private:
186 // should instead be shared from 181 // should instead be shared from
187 std::shared_ptr<Core::Frontend::GraphicsContext> main_context; 182 std::shared_ptr<Core::Frontend::GraphicsContext> main_context;
188 183
189#ifdef HAS_VULKAN
190 std::unique_ptr<QVulkanInstance> vk_instance;
191#endif
192
193 /// Temporary storage of the screenshot taken 184 /// Temporary storage of the screenshot taken
194 QImage screenshot_image; 185 QImage screenshot_image;
195 186
diff --git a/src/yuzu/configuration/configure_graphics.cpp b/src/yuzu/configuration/configure_graphics.cpp
index a821c7b3c..ea667caef 100644
--- a/src/yuzu/configuration/configure_graphics.cpp
+++ b/src/yuzu/configuration/configure_graphics.cpp
@@ -15,6 +15,10 @@
15#include "ui_configure_graphics.h" 15#include "ui_configure_graphics.h"
16#include "yuzu/configuration/configure_graphics.h" 16#include "yuzu/configuration/configure_graphics.h"
17 17
18#ifdef HAS_VULKAN
19#include "video_core/renderer_vulkan/renderer_vulkan.h"
20#endif
21
18namespace { 22namespace {
19enum class Resolution : int { 23enum class Resolution : int {
20 Auto, 24 Auto,
@@ -165,41 +169,9 @@ void ConfigureGraphics::UpdateDeviceComboBox() {
165 169
166void ConfigureGraphics::RetrieveVulkanDevices() { 170void ConfigureGraphics::RetrieveVulkanDevices() {
167#ifdef HAS_VULKAN 171#ifdef HAS_VULKAN
168 QVulkanInstance instance; 172 vulkan_devices.clear();
169 instance.setApiVersion(QVersionNumber(1, 1, 0)); 173 for (auto& name : Vulkan::RendererVulkan::EnumerateDevices()) {
170 if (!instance.create()) { 174 vulkan_devices.push_back(QString::fromStdString(name));
171 LOG_INFO(Frontend, "Vulkan 1.1 not available");
172 return;
173 }
174 const auto vkEnumeratePhysicalDevices{reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(
175 instance.getInstanceProcAddr("vkEnumeratePhysicalDevices"))};
176 if (vkEnumeratePhysicalDevices == nullptr) {
177 LOG_INFO(Frontend, "Failed to get pointer to vkEnumeratePhysicalDevices");
178 return;
179 }
180 u32 physical_device_count;
181 if (vkEnumeratePhysicalDevices(instance.vkInstance(), &physical_device_count, nullptr) !=
182 VK_SUCCESS) {
183 LOG_INFO(Frontend, "Failed to get physical devices count");
184 return;
185 }
186 std::vector<VkPhysicalDevice> physical_devices(physical_device_count);
187 if (vkEnumeratePhysicalDevices(instance.vkInstance(), &physical_device_count,
188 physical_devices.data()) != VK_SUCCESS) {
189 LOG_INFO(Frontend, "Failed to get physical devices");
190 return;
191 }
192
193 const auto vkGetPhysicalDeviceProperties{reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(
194 instance.getInstanceProcAddr("vkGetPhysicalDeviceProperties"))};
195 if (vkGetPhysicalDeviceProperties == nullptr) {
196 LOG_INFO(Frontend, "Failed to get pointer to vkGetPhysicalDeviceProperties");
197 return;
198 }
199 for (const auto physical_device : physical_devices) {
200 VkPhysicalDeviceProperties properties;
201 vkGetPhysicalDeviceProperties(physical_device, &properties);
202 vulkan_devices.push_back(QString::fromUtf8(properties.deviceName));
203 } 175 }
204#endif 176#endif
205} 177}
diff --git a/src/yuzu/configuration/configure_input_player.cpp b/src/yuzu/configuration/configure_input_player.cpp
index 96dec50e2..15ac30f12 100644
--- a/src/yuzu/configuration/configure_input_player.cpp
+++ b/src/yuzu/configuration/configure_input_player.cpp
@@ -541,18 +541,19 @@ void ConfigureInputPlayer::HandleClick(
541 button->setText(tr("[press key]")); 541 button->setText(tr("[press key]"));
542 button->setFocus(); 542 button->setFocus();
543 543
544 const auto iter = std::find(button_map.begin(), button_map.end(), button); 544 // Keyboard keys can only be used as button devices
545 ASSERT(iter != button_map.end()); 545 want_keyboard_keys = type == InputCommon::Polling::DeviceType::Button;
546 const auto index = std::distance(button_map.begin(), iter); 546 if (want_keyboard_keys) {
547 ASSERT(index < Settings::NativeButton::NumButtons && index >= 0); 547 const auto iter = std::find(button_map.begin(), button_map.end(), button);
548 ASSERT(iter != button_map.end());
549 const auto index = std::distance(button_map.begin(), iter);
550 ASSERT(index < Settings::NativeButton::NumButtons && index >= 0);
551 }
548 552
549 input_setter = new_input_setter; 553 input_setter = new_input_setter;
550 554
551 device_pollers = InputCommon::Polling::GetPollers(type); 555 device_pollers = InputCommon::Polling::GetPollers(type);
552 556
553 // Keyboard keys can only be used as button devices
554 want_keyboard_keys = type == InputCommon::Polling::DeviceType::Button;
555
556 for (auto& poller : device_pollers) { 557 for (auto& poller : device_pollers) {
557 poller->Start(); 558 poller->Start();
558 } 559 }
diff --git a/src/yuzu/configuration/configure_input_simple.cpp b/src/yuzu/configuration/configure_input_simple.cpp
index ab3a11d30..0e0e8f113 100644
--- a/src/yuzu/configuration/configure_input_simple.cpp
+++ b/src/yuzu/configuration/configure_input_simple.cpp
@@ -35,6 +35,7 @@ void CallConfigureDialog(ConfigureInputSimple* caller, Args&&... args) {
35// - Open any dialogs 35// - Open any dialogs
36// - Block in any way 36// - Block in any way
37 37
38constexpr std::size_t PLAYER_0_INDEX = 0;
38constexpr std::size_t HANDHELD_INDEX = 8; 39constexpr std::size_t HANDHELD_INDEX = 8;
39 40
40void HandheldOnProfileSelect() { 41void HandheldOnProfileSelect() {
@@ -53,8 +54,8 @@ void HandheldOnProfileSelect() {
53} 54}
54 55
55void DualJoyconsDockedOnProfileSelect() { 56void DualJoyconsDockedOnProfileSelect() {
56 Settings::values.players[0].connected = true; 57 Settings::values.players[PLAYER_0_INDEX].connected = true;
57 Settings::values.players[0].type = Settings::ControllerType::DualJoycon; 58 Settings::values.players[PLAYER_0_INDEX].type = Settings::ControllerType::DualJoycon;
58 59
59 for (std::size_t player = 1; player <= HANDHELD_INDEX; ++player) { 60 for (std::size_t player = 1; player <= HANDHELD_INDEX; ++player) {
60 Settings::values.players[player].connected = false; 61 Settings::values.players[player].connected = false;
@@ -64,7 +65,7 @@ void DualJoyconsDockedOnProfileSelect() {
64 Settings::values.keyboard_enabled = false; 65 Settings::values.keyboard_enabled = false;
65 Settings::values.mouse_enabled = false; 66 Settings::values.mouse_enabled = false;
66 Settings::values.debug_pad_enabled = false; 67 Settings::values.debug_pad_enabled = false;
67 Settings::values.touchscreen.enabled = false; 68 Settings::values.touchscreen.enabled = true;
68} 69}
69 70
70// Name, OnProfileSelect (called when selected in drop down), OnConfigure (called when configure 71// Name, OnProfileSelect (called when selected in drop down), OnConfigure (called when configure
@@ -78,7 +79,7 @@ constexpr std::array<InputProfile, 3> INPUT_PROFILES{{
78 }}, 79 }},
79 {QT_TR_NOOP("Single Player - Dual Joycons - Docked"), DualJoyconsDockedOnProfileSelect, 80 {QT_TR_NOOP("Single Player - Dual Joycons - Docked"), DualJoyconsDockedOnProfileSelect,
80 [](ConfigureInputSimple* caller) { 81 [](ConfigureInputSimple* caller) {
81 CallConfigureDialog<ConfigureInputPlayer>(caller, 1, false); 82 CallConfigureDialog<ConfigureInputPlayer>(caller, PLAYER_0_INDEX, false);
82 }}, 83 }},
83 {QT_TR_NOOP("Custom"), [] {}, CallConfigureDialog<ConfigureInput>}, 84 {QT_TR_NOOP("Custom"), [] {}, CallConfigureDialog<ConfigureInput>},
84}}; 85}};
diff --git a/src/yuzu/configuration/configure_mouse_advanced.cpp b/src/yuzu/configuration/configure_mouse_advanced.cpp
index 0a4abe34f..e0647ea5b 100644
--- a/src/yuzu/configuration/configure_mouse_advanced.cpp
+++ b/src/yuzu/configuration/configure_mouse_advanced.cpp
@@ -184,18 +184,19 @@ void ConfigureMouseAdvanced::HandleClick(
184 button->setText(tr("[press key]")); 184 button->setText(tr("[press key]"));
185 button->setFocus(); 185 button->setFocus();
186 186
187 const auto iter = std::find(button_map.begin(), button_map.end(), button); 187 // Keyboard keys can only be used as button devices
188 ASSERT(iter != button_map.end()); 188 want_keyboard_keys = type == InputCommon::Polling::DeviceType::Button;
189 const auto index = std::distance(button_map.begin(), iter); 189 if (want_keyboard_keys) {
190 ASSERT(index < Settings::NativeButton::NumButtons && index >= 0); 190 const auto iter = std::find(button_map.begin(), button_map.end(), button);
191 ASSERT(iter != button_map.end());
192 const auto index = std::distance(button_map.begin(), iter);
193 ASSERT(index < Settings::NativeButton::NumButtons && index >= 0);
194 }
191 195
192 input_setter = new_input_setter; 196 input_setter = new_input_setter;
193 197
194 device_pollers = InputCommon::Polling::GetPollers(type); 198 device_pollers = InputCommon::Polling::GetPollers(type);
195 199
196 // Keyboard keys can only be used as button devices
197 want_keyboard_keys = type == InputCommon::Polling::DeviceType::Button;
198
199 for (auto& poller : device_pollers) { 200 for (auto& poller : device_pollers) {
200 poller->Start(); 201 poller->Start();
201 } 202 }
diff --git a/src/yuzu/game_list.cpp b/src/yuzu/game_list.cpp
index a2b88c787..dccbabcbf 100644
--- a/src/yuzu/game_list.cpp
+++ b/src/yuzu/game_list.cpp
@@ -315,7 +315,7 @@ GameList::GameList(FileSys::VirtualFilesystem vfs, FileSys::ManualContentProvide
315 item_model->setHeaderData(COLUMN_FILE_TYPE - 1, Qt::Horizontal, tr("File type")); 315 item_model->setHeaderData(COLUMN_FILE_TYPE - 1, Qt::Horizontal, tr("File type"));
316 item_model->setHeaderData(COLUMN_SIZE - 1, Qt::Horizontal, tr("Size")); 316 item_model->setHeaderData(COLUMN_SIZE - 1, Qt::Horizontal, tr("Size"));
317 } 317 }
318 item_model->setSortRole(GameListItemPath::TitleRole); 318 item_model->setSortRole(GameListItemPath::SortRole);
319 319
320 connect(main_window, &GMainWindow::UpdateThemedIcons, this, &GameList::onUpdateThemedIcons); 320 connect(main_window, &GMainWindow::UpdateThemedIcons, this, &GameList::onUpdateThemedIcons);
321 connect(tree_view, &QTreeView::activated, this, &GameList::ValidateEntry); 321 connect(tree_view, &QTreeView::activated, this, &GameList::ValidateEntry);
@@ -441,6 +441,8 @@ void GameList::DonePopulating(QStringList watch_list) {
441 if (children_total > 0) { 441 if (children_total > 0) {
442 search_field->setFocus(); 442 search_field->setFocus();
443 } 443 }
444 item_model->sort(tree_view->header()->sortIndicatorSection(),
445 tree_view->header()->sortIndicatorOrder());
444} 446}
445 447
446void GameList::PopupContextMenu(const QPoint& menu_location) { 448void GameList::PopupContextMenu(const QPoint& menu_location) {
@@ -666,8 +668,6 @@ void GameList::LoadInterfaceLayout() {
666 // so make it as large as possible as default. 668 // so make it as large as possible as default.
667 header->resizeSection(COLUMN_NAME, header->width()); 669 header->resizeSection(COLUMN_NAME, header->width());
668 } 670 }
669
670 item_model->sort(header->sortIndicatorSection(), header->sortIndicatorOrder());
671} 671}
672 672
673const QStringList GameList::supported_file_extensions = { 673const QStringList GameList::supported_file_extensions = {
diff --git a/src/yuzu/game_list_p.h b/src/yuzu/game_list_p.h
index 7cde72d1b..3e6d5a7cd 100644
--- a/src/yuzu/game_list_p.h
+++ b/src/yuzu/game_list_p.h
@@ -65,10 +65,10 @@ public:
65 */ 65 */
66class GameListItemPath : public GameListItem { 66class GameListItemPath : public GameListItem {
67public: 67public:
68 static const int TitleRole = SortRole; 68 static const int TitleRole = SortRole + 1;
69 static const int FullPathRole = SortRole + 1; 69 static const int FullPathRole = SortRole + 2;
70 static const int ProgramIdRole = SortRole + 2; 70 static const int ProgramIdRole = SortRole + 3;
71 static const int FileTypeRole = SortRole + 3; 71 static const int FileTypeRole = SortRole + 4;
72 72
73 GameListItemPath() = default; 73 GameListItemPath() = default;
74 GameListItemPath(const QString& game_path, const std::vector<u8>& picture_data, 74 GameListItemPath(const QString& game_path, const std::vector<u8>& picture_data,
@@ -95,7 +95,7 @@ public:
95 } 95 }
96 96
97 QVariant data(int role) const override { 97 QVariant data(int role) const override {
98 if (role == Qt::DisplayRole) { 98 if (role == Qt::DisplayRole || role == SortRole) {
99 std::string filename; 99 std::string filename;
100 Common::SplitPath(data(FullPathRole).toString().toStdString(), nullptr, &filename, 100 Common::SplitPath(data(FullPathRole).toString().toStdString(), nullptr, &filename,
101 nullptr); 101 nullptr);
@@ -110,6 +110,9 @@ public:
110 const auto& row1 = row_data.at(UISettings::values.row_1_text_id); 110 const auto& row1 = row_data.at(UISettings::values.row_1_text_id);
111 const int row2_id = UISettings::values.row_2_text_id; 111 const int row2_id = UISettings::values.row_2_text_id;
112 112
113 if (role == SortRole)
114 return row1.toLower();
115
113 if (row2_id == 4) // None 116 if (row2_id == 4) // None
114 return row1; 117 return row1;
115 118
@@ -123,6 +126,13 @@ public:
123 126
124 return GameListItem::data(role); 127 return GameListItem::data(role);
125 } 128 }
129
130 /**
131 * Override to prevent automatic sorting.
132 */
133 bool operator<(const QStandardItem& other) const override {
134 return false;
135 }
126}; 136};
127 137
128class GameListItemCompat : public GameListItem { 138class GameListItemCompat : public GameListItem {
@@ -289,6 +299,10 @@ public:
289 int type() const override { 299 int type() const override {
290 return static_cast<int>(GameListItemType::AddDir); 300 return static_cast<int>(GameListItemType::AddDir);
291 } 301 }
302
303 bool operator<(const QStandardItem& other) const override {
304 return false;
305 }
292}; 306};
293 307
294class GameList; 308class GameList;
diff --git a/src/yuzu_cmd/emu_window/emu_window_sdl2_gl.cpp b/src/yuzu_cmd/emu_window/emu_window_sdl2_gl.cpp
index 3522dcf6d..411e7e647 100644
--- a/src/yuzu_cmd/emu_window/emu_window_sdl2_gl.cpp
+++ b/src/yuzu_cmd/emu_window/emu_window_sdl2_gl.cpp
@@ -156,12 +156,6 @@ EmuWindow_SDL2_GL::~EmuWindow_SDL2_GL() {
156 SDL_GL_DeleteContext(window_context); 156 SDL_GL_DeleteContext(window_context);
157} 157}
158 158
159void EmuWindow_SDL2_GL::RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
160 void* surface) const {
161 // Should not have been called from OpenGL
162 UNREACHABLE();
163}
164
165std::unique_ptr<Core::Frontend::GraphicsContext> EmuWindow_SDL2_GL::CreateSharedContext() const { 159std::unique_ptr<Core::Frontend::GraphicsContext> EmuWindow_SDL2_GL::CreateSharedContext() const {
166 return std::make_unique<SDLGLContext>(); 160 return std::make_unique<SDLGLContext>();
167} 161}
diff --git a/src/yuzu_cmd/emu_window/emu_window_sdl2_gl.h b/src/yuzu_cmd/emu_window/emu_window_sdl2_gl.h
index e092021d7..48bb41683 100644
--- a/src/yuzu_cmd/emu_window/emu_window_sdl2_gl.h
+++ b/src/yuzu_cmd/emu_window/emu_window_sdl2_gl.h
@@ -15,10 +15,6 @@ public:
15 15
16 void Present() override; 16 void Present() override;
17 17
18 /// Ignored in OpenGL
19 void RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
20 void* surface) const override;
21
22 std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override; 18 std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override;
23 19
24private: 20private:
diff --git a/src/yuzu_cmd/emu_window/emu_window_sdl2_vk.cpp b/src/yuzu_cmd/emu_window/emu_window_sdl2_vk.cpp
index 46d053f04..f2990910e 100644
--- a/src/yuzu_cmd/emu_window/emu_window_sdl2_vk.cpp
+++ b/src/yuzu_cmd/emu_window/emu_window_sdl2_vk.cpp
@@ -2,102 +2,62 @@
2// Licensed under GPLv2 or any later version 2// Licensed under GPLv2 or any later version
3// Refer to the license.txt file included. 3// Refer to the license.txt file included.
4 4
5#include <algorithm> 5#include <cstdlib>
6#include <memory>
6#include <string> 7#include <string>
7#include <vector> 8
8#include <SDL.h>
9#include <SDL_vulkan.h>
10#include <fmt/format.h> 9#include <fmt/format.h>
11#include <vulkan/vulkan.h> 10
12#include "common/assert.h" 11#include "common/assert.h"
13#include "common/logging/log.h" 12#include "common/logging/log.h"
14#include "common/scm_rev.h" 13#include "common/scm_rev.h"
15#include "core/settings.h" 14#include "core/settings.h"
15#include "video_core/renderer_vulkan/renderer_vulkan.h"
16#include "yuzu_cmd/emu_window/emu_window_sdl2_vk.h" 16#include "yuzu_cmd/emu_window/emu_window_sdl2_vk.h"
17 17
18// Include these late to avoid polluting everything with Xlib macros
19#include <SDL.h>
20#include <SDL_syswm.h>
21
18EmuWindow_SDL2_VK::EmuWindow_SDL2_VK(Core::System& system, bool fullscreen) 22EmuWindow_SDL2_VK::EmuWindow_SDL2_VK(Core::System& system, bool fullscreen)
19 : EmuWindow_SDL2{system, fullscreen} { 23 : EmuWindow_SDL2{system, fullscreen} {
20 if (SDL_Vulkan_LoadLibrary(nullptr) != 0) {
21 LOG_CRITICAL(Frontend, "SDL failed to load the Vulkan library: {}", SDL_GetError());
22 exit(EXIT_FAILURE);
23 }
24
25 vkGetInstanceProcAddr =
26 reinterpret_cast<PFN_vkGetInstanceProcAddr>(SDL_Vulkan_GetVkGetInstanceProcAddr());
27 if (vkGetInstanceProcAddr == nullptr) {
28 LOG_CRITICAL(Frontend, "Failed to retrieve Vulkan function pointer!");
29 exit(EXIT_FAILURE);
30 }
31
32 const std::string window_title = fmt::format("yuzu {} | {}-{} (Vulkan)", Common::g_build_name, 24 const std::string window_title = fmt::format("yuzu {} | {}-{} (Vulkan)", Common::g_build_name,
33 Common::g_scm_branch, Common::g_scm_desc); 25 Common::g_scm_branch, Common::g_scm_desc);
34 render_window = 26 render_window =
35 SDL_CreateWindow(window_title.c_str(), 27 SDL_CreateWindow(window_title.c_str(), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
36 SDL_WINDOWPOS_UNDEFINED, // x position
37 SDL_WINDOWPOS_UNDEFINED, // y position
38 Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height, 28 Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height,
39 SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_VULKAN); 29 SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
40
41 const bool use_standard_layers = UseStandardLayers(vkGetInstanceProcAddr);
42
43 u32 extra_ext_count{};
44 if (!SDL_Vulkan_GetInstanceExtensions(render_window, &extra_ext_count, NULL)) {
45 LOG_CRITICAL(Frontend, "Failed to query Vulkan extensions count from SDL! {}",
46 SDL_GetError());
47 exit(1);
48 }
49
50 auto extra_ext_names = std::make_unique<const char* []>(extra_ext_count);
51 if (!SDL_Vulkan_GetInstanceExtensions(render_window, &extra_ext_count, extra_ext_names.get())) {
52 LOG_CRITICAL(Frontend, "Failed to query Vulkan extensions from SDL! {}", SDL_GetError());
53 exit(1);
54 }
55 std::vector<const char*> enabled_extensions;
56 enabled_extensions.insert(enabled_extensions.begin(), extra_ext_names.get(),
57 extra_ext_names.get() + extra_ext_count);
58
59 std::vector<const char*> enabled_layers;
60 if (use_standard_layers) {
61 enabled_extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
62 enabled_layers.push_back("VK_LAYER_LUNARG_standard_validation");
63 }
64
65 VkApplicationInfo app_info{};
66 app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
67 app_info.apiVersion = VK_API_VERSION_1_1;
68 app_info.applicationVersion = VK_MAKE_VERSION(0, 1, 0);
69 app_info.pApplicationName = "yuzu-emu";
70 app_info.engineVersion = VK_MAKE_VERSION(0, 1, 0);
71 app_info.pEngineName = "yuzu-emu";
72 30
73 VkInstanceCreateInfo instance_ci{}; 31 SDL_SysWMinfo wm;
74 instance_ci.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; 32 if (SDL_GetWindowWMInfo(render_window, &wm) == SDL_FALSE) {
75 instance_ci.pApplicationInfo = &app_info; 33 LOG_CRITICAL(Frontend, "Failed to get information from the window manager");
76 instance_ci.enabledExtensionCount = static_cast<u32>(enabled_extensions.size()); 34 std::exit(EXIT_FAILURE);
77 instance_ci.ppEnabledExtensionNames = enabled_extensions.data();
78 if (Settings::values.renderer_debug) {
79 instance_ci.enabledLayerCount = static_cast<u32>(enabled_layers.size());
80 instance_ci.ppEnabledLayerNames = enabled_layers.data();
81 } 35 }
82 36
83 const auto vkCreateInstance = 37 switch (wm.subsystem) {
84 reinterpret_cast<PFN_vkCreateInstance>(vkGetInstanceProcAddr(nullptr, "vkCreateInstance")); 38#ifdef SDL_VIDEO_DRIVER_WINDOWS
85 if (vkCreateInstance == nullptr || 39 case SDL_SYSWM_TYPE::SDL_SYSWM_WINDOWS:
86 vkCreateInstance(&instance_ci, nullptr, &vk_instance) != VK_SUCCESS) { 40 window_info.type = Core::Frontend::WindowSystemType::Windows;
87 LOG_CRITICAL(Frontend, "Failed to create Vulkan instance!"); 41 window_info.render_surface = reinterpret_cast<void*>(wm.info.win.window);
88 exit(EXIT_FAILURE); 42 break;
89 } 43#endif
90 44#ifdef SDL_VIDEO_DRIVER_X11
91 vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>( 45 case SDL_SYSWM_TYPE::SDL_SYSWM_X11:
92 vkGetInstanceProcAddr(vk_instance, "vkDestroyInstance")); 46 window_info.type = Core::Frontend::WindowSystemType::X11;
93 if (vkDestroyInstance == nullptr) { 47 window_info.display_connection = wm.info.x11.display;
94 LOG_CRITICAL(Frontend, "Failed to retrieve Vulkan function pointer!"); 48 window_info.render_surface = reinterpret_cast<void*>(wm.info.x11.window);
95 exit(EXIT_FAILURE); 49 break;
96 } 50#endif
97 51#ifdef SDL_VIDEO_DRIVER_WAYLAND
98 if (!SDL_Vulkan_CreateSurface(render_window, vk_instance, &vk_surface)) { 52 case SDL_SYSWM_TYPE::SDL_SYSWM_WAYLAND:
99 LOG_CRITICAL(Frontend, "Failed to create Vulkan surface! {}", SDL_GetError()); 53 window_info.type = Core::Frontend::WindowSystemType::Wayland;
100 exit(EXIT_FAILURE); 54 window_info.display_connection = wm.info.wl.display;
55 window_info.render_surface = wm.info.wl.surface;
56 break;
57#endif
58 default:
59 LOG_CRITICAL(Frontend, "Window manager subsystem not implemented");
60 std::exit(EXIT_FAILURE);
101 } 61 }
102 62
103 OnResize(); 63 OnResize();
@@ -107,51 +67,12 @@ EmuWindow_SDL2_VK::EmuWindow_SDL2_VK(Core::System& system, bool fullscreen)
107 Common::g_scm_branch, Common::g_scm_desc); 67 Common::g_scm_branch, Common::g_scm_desc);
108} 68}
109 69
110EmuWindow_SDL2_VK::~EmuWindow_SDL2_VK() { 70EmuWindow_SDL2_VK::~EmuWindow_SDL2_VK() = default;
111 vkDestroyInstance(vk_instance, nullptr);
112}
113
114void EmuWindow_SDL2_VK::RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
115 void* surface) const {
116 const auto instance_proc_addr = vkGetInstanceProcAddr;
117 std::memcpy(get_instance_proc_addr, &instance_proc_addr, sizeof(instance_proc_addr));
118 std::memcpy(instance, &vk_instance, sizeof(vk_instance));
119 std::memcpy(surface, &vk_surface, sizeof(vk_surface));
120}
121 71
122std::unique_ptr<Core::Frontend::GraphicsContext> EmuWindow_SDL2_VK::CreateSharedContext() const { 72std::unique_ptr<Core::Frontend::GraphicsContext> EmuWindow_SDL2_VK::CreateSharedContext() const {
123 return nullptr; 73 return nullptr;
124} 74}
125 75
126bool EmuWindow_SDL2_VK::UseStandardLayers(PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr) const {
127 if (!Settings::values.renderer_debug) {
128 return false;
129 }
130
131 const auto vkEnumerateInstanceLayerProperties =
132 reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(
133 vkGetInstanceProcAddr(nullptr, "vkEnumerateInstanceLayerProperties"));
134 if (vkEnumerateInstanceLayerProperties == nullptr) {
135 LOG_CRITICAL(Frontend, "Failed to retrieve Vulkan function pointer!");
136 return false;
137 }
138
139 u32 available_layers_count{};
140 if (vkEnumerateInstanceLayerProperties(&available_layers_count, nullptr) != VK_SUCCESS) {
141 LOG_CRITICAL(Frontend, "Failed to enumerate Vulkan validation layers!");
142 return false;
143 }
144 std::vector<VkLayerProperties> layers(available_layers_count);
145 if (vkEnumerateInstanceLayerProperties(&available_layers_count, layers.data()) != VK_SUCCESS) {
146 LOG_CRITICAL(Frontend, "Failed to enumerate Vulkan validation layers!");
147 return false;
148 }
149
150 return std::find_if(layers.begin(), layers.end(), [&](const auto& layer) {
151 return layer.layerName == std::string("VK_LAYER_LUNARG_standard_validation");
152 }) != layers.end();
153}
154
155void EmuWindow_SDL2_VK::Present() { 76void EmuWindow_SDL2_VK::Present() {
156 // TODO (bunnei): ImplementMe 77 // TODO (bunnei): ImplementMe
157} 78}
diff --git a/src/yuzu_cmd/emu_window/emu_window_sdl2_vk.h b/src/yuzu_cmd/emu_window/emu_window_sdl2_vk.h
index 3dd1f3f61..b8021ebea 100644
--- a/src/yuzu_cmd/emu_window/emu_window_sdl2_vk.h
+++ b/src/yuzu_cmd/emu_window/emu_window_sdl2_vk.h
@@ -4,27 +4,21 @@
4 4
5#pragma once 5#pragma once
6 6
7#include <vulkan/vulkan.h> 7#include <memory>
8
8#include "core/frontend/emu_window.h" 9#include "core/frontend/emu_window.h"
9#include "yuzu_cmd/emu_window/emu_window_sdl2.h" 10#include "yuzu_cmd/emu_window/emu_window_sdl2.h"
10 11
12namespace Core {
13class System;
14}
15
11class EmuWindow_SDL2_VK final : public EmuWindow_SDL2 { 16class EmuWindow_SDL2_VK final : public EmuWindow_SDL2 {
12public: 17public:
13 explicit EmuWindow_SDL2_VK(Core::System& system, bool fullscreen); 18 explicit EmuWindow_SDL2_VK(Core::System& system, bool fullscreen);
14 ~EmuWindow_SDL2_VK(); 19 ~EmuWindow_SDL2_VK();
15 20
16 void Present() override; 21 void Present() override;
17 void RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
18 void* surface) const override;
19 22
20 std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override; 23 std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override;
21
22private:
23 bool UseStandardLayers(PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr) const;
24
25 VkInstance vk_instance{};
26 VkSurfaceKHR vk_surface{};
27
28 PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr{};
29 PFN_vkDestroyInstance vkDestroyInstance{};
30}; 24};
diff --git a/src/yuzu_tester/emu_window/emu_window_sdl2_hide.cpp b/src/yuzu_tester/emu_window/emu_window_sdl2_hide.cpp
index a837430cc..8584f6671 100644
--- a/src/yuzu_tester/emu_window/emu_window_sdl2_hide.cpp
+++ b/src/yuzu_tester/emu_window/emu_window_sdl2_hide.cpp
@@ -116,10 +116,6 @@ bool EmuWindow_SDL2_Hide::IsShown() const {
116 return false; 116 return false;
117} 117}
118 118
119void EmuWindow_SDL2_Hide::RetrieveVulkanHandlers(void*, void*, void*) const {
120 UNREACHABLE();
121}
122
123class SDLGLContext : public Core::Frontend::GraphicsContext { 119class SDLGLContext : public Core::Frontend::GraphicsContext {
124public: 120public:
125 explicit SDLGLContext() { 121 explicit SDLGLContext() {
diff --git a/src/yuzu_tester/emu_window/emu_window_sdl2_hide.h b/src/yuzu_tester/emu_window/emu_window_sdl2_hide.h
index 9f5d04fca..c13a82df2 100644
--- a/src/yuzu_tester/emu_window/emu_window_sdl2_hide.h
+++ b/src/yuzu_tester/emu_window/emu_window_sdl2_hide.h
@@ -19,10 +19,6 @@ public:
19 /// Whether the screen is being shown or not. 19 /// Whether the screen is being shown or not.
20 bool IsShown() const override; 20 bool IsShown() const override;
21 21
22 /// Retrieves Vulkan specific handlers from the window
23 void RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
24 void* surface) const override;
25
26 std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override; 22 std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override;
27 23
28private: 24private:
HIC SVNT DRACONES