Android #144

.github/workflows/verify.yml

@@ -68,25 +68,6 @@ jobs:
         with:
           name: ${{ matrix.type }}
           path: artifacts/
-  build-mac:
-    name: 'test build (macos)'
-    needs: format
-    runs-on: macos-13
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: recursive
-          fetch-depth: 0
-      - name: Install dependencies
-        run: |
-          brew install autoconf automake boost@1.83 ccache ffmpeg fmt glslang hidapi libtool libusb lz4 ninja nlohmann-json openssl pkg-config qt@5 sdl2 speexdsp zlib zlib zstd
-      - name: Build
-        run: |
-          mkdir build
-          cd build
-          export Qt5_DIR="/usr/local/opt/qt@5/lib/cmake"
-          cmake .. -GNinja -DCMAKE_BUILD_TYPE=RelWithDebInfo -DYUZU_USE_BUNDLED_VCPKG=OFF -DYUZU_TESTS=OFF -DENABLE_WEB_SERVICE=OFF -DENABLE_LIBUSB=OFF
-          ninja
   build-msvc:
     name: 'test build (windows, msvc)'
     needs: format

.reuse/dep5

@@ -151,7 +151,3 @@ License: GPL-3.0-or-later
 Files: externals/stb/*
 Copyright: Sean Barrett
 License: MIT
-
-Files: externals/gamemode/*
-Copyright: Copyright 2017-2019 Feral Interactive
-License: BSD-3-Clause

CMakeLists.txt

@@ -343,10 +343,6 @@ if(ENABLE_OPENSSL)
     find_package(OpenSSL 1.1.1 REQUIRED)
 endif()
 
-if (UNIX AND NOT APPLE)
-    find_package(gamemode 1.7 MODULE)
-endif()
-
 # Please consider this as a stub
 if(ENABLE_QT6 AND Qt6_LOCATION)
     list(APPEND CMAKE_PREFIX_PATH "${Qt6_LOCATION}")

CMakeModules/Findgamemode.cmake

@@ -1,15 +0,0 @@
-# SPDX-FileCopyrightText: 2023 yuzu Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-find_package(PkgConfig QUIET)
-pkg_search_module(GAMEMODE QUIET IMPORTED_TARGET gamemode)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(gamemode
-    REQUIRED_VARS GAMEMODE_INCLUDEDIR
-    VERSION_VAR GAMEMODE_VERSION
-)
-
-if (gamemode_FOUND AND NOT TARGET gamemode::headers)
-    add_library(gamemode::headers ALIAS PkgConfig::GAMEMODE)
-endif()

README.md

@@ -1,6 +1,7 @@
 | Pull Request | Commit | Title | Author | Merged? |
 |----|----|----|----|----|
-| [12235](https://github.com/yuzu-emu/yuzu//pull/12235) | [`e7dd968ac`](https://github.com/yuzu-emu/yuzu//pull/12235/files) | renderer_vulkan: adjust window origin and swizzle independently | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12074](https://github.com/yuzu-emu/yuzu//pull/12074) | [`a76a8fb5f`](https://github.com/yuzu-emu/yuzu//pull/12074/files) | Implement Native Code Execution (NCE) | [GPUCode](https://github.com/GPUCode/) | Yes |
+| [12204](https://github.com/yuzu-emu/yuzu//pull/12204) | [`caa83609f`](https://github.com/yuzu-emu/yuzu//pull/12204/files) | android: Multi directory UI | [t895](https://github.com/t895/) | Yes |
 
 
 End of merge log. You can find the original README.md below the break.

externals/CMakeLists.txt

@@ -193,12 +193,6 @@ if (ANDROID)
    endif()
 endif()
 
-if (UNIX AND NOT APPLE AND NOT TARGET gamemode::headers)
-    add_library(gamemode INTERFACE)
-    target_include_directories(gamemode INTERFACE gamemode)
-    add_library(gamemode::headers ALIAS gamemode)
-endif()
-
 # Breakpad
 # https://github.com/microsoft/vcpkg/blob/master/ports/breakpad/CMakeLists.txt
 if (YUZU_CRASH_DUMPS AND NOT TARGET libbreakpad_client)

externals/gamemode/gamemode_client.h

@@ -1,376 +0,0 @@
-/*
-
-Copyright (c) 2017-2019, Feral Interactive
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- * Redistributions of source code must retain the above copyright notice,
-   this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
- * Neither the name of Feral Interactive nor the names of its contributors
-   may be used to endorse or promote products derived from this software
-   without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.
-
- */
-#ifndef CLIENT_GAMEMODE_H
-#define CLIENT_GAMEMODE_H
-/*
- * GameMode supports the following client functions
- * Requests are refcounted in the daemon
- *
- * int gamemode_request_start() - Request gamemode starts
- *   0 if the request was sent successfully
- *   -1 if the request failed
- *
- * int gamemode_request_end() - Request gamemode ends
- *   0 if the request was sent successfully
- *   -1 if the request failed
- *
- * GAMEMODE_AUTO can be defined to make the above two functions apply during static init and
- * destruction, as appropriate. In this configuration, errors will be printed to stderr
- *
- * int gamemode_query_status() - Query the current status of gamemode
- *   0 if gamemode is inactive
- *   1 if gamemode is active
- *   2 if gamemode is active and this client is registered
- *   -1 if the query failed
- *
- * int gamemode_request_start_for(pid_t pid) - Request gamemode starts for another process
- *   0 if the request was sent successfully
- *   -1 if the request failed
- *   -2 if the request was rejected
- *
- * int gamemode_request_end_for(pid_t pid) - Request gamemode ends for another process
- *   0 if the request was sent successfully
- *   -1 if the request failed
- *   -2 if the request was rejected
- *
- * int gamemode_query_status_for(pid_t pid) - Query status of gamemode for another process
- *   0 if gamemode is inactive
- *   1 if gamemode is active
- *   2 if gamemode is active and this client is registered
- *   -1 if the query failed
- *
- * const char* gamemode_error_string() - Get an error string
- *   returns a string describing any of the above errors
- *
- * Note: All the above requests can be blocking - dbus requests can and will block while the daemon
- * handles the request. It is not recommended to make these calls in performance critical code
- */
-
-#include <stdbool.h>
-#include <stdio.h>
-
-#include <dlfcn.h>
-#include <string.h>
-
-#include <assert.h>
-
-#include <sys/types.h>
-
-static char internal_gamemode_client_error_string[512] = { 0 };
-
-/**
- * Load libgamemode dynamically to dislodge us from most dependencies.
- * This allows clients to link and/or use this regardless of runtime.
- * See SDL2 for an example of the reasoning behind this in terms of
- * dynamic versioning as well.
- */
-static volatile int internal_libgamemode_loaded = 1;
-
-/* Typedefs for the functions to load */
-typedef int (*api_call_return_int)(void);
-typedef const char *(*api_call_return_cstring)(void);
-typedef int (*api_call_pid_return_int)(pid_t);
-
-/* Storage for functors */
-static api_call_return_int REAL_internal_gamemode_request_start = NULL;
-static api_call_return_int REAL_internal_gamemode_request_end = NULL;
-static api_call_return_int REAL_internal_gamemode_query_status = NULL;
-static api_call_return_cstring REAL_internal_gamemode_error_string = NULL;
-static api_call_pid_return_int REAL_internal_gamemode_request_start_for = NULL;
-static api_call_pid_return_int REAL_internal_gamemode_request_end_for = NULL;
-static api_call_pid_return_int REAL_internal_gamemode_query_status_for = NULL;
-
-/**
- * Internal helper to perform the symbol binding safely.
- *
- * Returns 0 on success and -1 on failure
- */
-__attribute__((always_inline)) static inline int internal_bind_libgamemode_symbol(
-    void *handle, const char *name, void **out_func, size_t func_size, bool required)
-{
-	void *symbol_lookup = NULL;
-	char *dl_error = NULL;
-
-	/* Safely look up the symbol */
-	symbol_lookup = dlsym(handle, name);
-	dl_error = dlerror();
-	if (required && (dl_error || !symbol_lookup)) {
-		snprintf(internal_gamemode_client_error_string,
-		         sizeof(internal_gamemode_client_error_string),
-		         "dlsym failed - %s",
-		         dl_error);
-		return -1;
-	}
-
-	/* Have the symbol correctly, copy it to make it usable */
-	memcpy(out_func, &symbol_lookup, func_size);
-	return 0;
-}
-
-/**
- * Loads libgamemode and needed functions
- *
- * Returns 0 on success and -1 on failure
- */
-__attribute__((always_inline)) static inline int internal_load_libgamemode(void)
-{
-	/* We start at 1, 0 is a success and -1 is a fail */
-	if (internal_libgamemode_loaded != 1) {
-		return internal_libgamemode_loaded;
-	}
-
-	/* Anonymous struct type to define our bindings */
-	struct binding {
-		const char *name;
-		void **functor;
-		size_t func_size;
-		bool required;
-	} bindings[] = {
-		{ "real_gamemode_request_start",
-		  (void **)&REAL_internal_gamemode_request_start,
-		  sizeof(REAL_internal_gamemode_request_start),
-		  true },
-		{ "real_gamemode_request_end",
-		  (void **)&REAL_internal_gamemode_request_end,
-		  sizeof(REAL_internal_gamemode_request_end),
-		  true },
-		{ "real_gamemode_query_status",
-		  (void **)&REAL_internal_gamemode_query_status,
-		  sizeof(REAL_internal_gamemode_query_status),
-		  false },
-		{ "real_gamemode_error_string",
-		  (void **)&REAL_internal_gamemode_error_string,
-		  sizeof(REAL_internal_gamemode_error_string),
-		  true },
-		{ "real_gamemode_request_start_for",
-		  (void **)&REAL_internal_gamemode_request_start_for,
-		  sizeof(REAL_internal_gamemode_request_start_for),
-		  false },
-		{ "real_gamemode_request_end_for",
-		  (void **)&REAL_internal_gamemode_request_end_for,
-		  sizeof(REAL_internal_gamemode_request_end_for),
-		  false },
-		{ "real_gamemode_query_status_for",
-		  (void **)&REAL_internal_gamemode_query_status_for,
-		  sizeof(REAL_internal_gamemode_query_status_for),
-		  false },
-	};
-
-	void *libgamemode = NULL;
-
-	/* Try and load libgamemode */
-	libgamemode = dlopen("libgamemode.so.0", RTLD_NOW);
-	if (!libgamemode) {
-		/* Attempt to load unversioned library for compatibility with older
-		 * versions (as of writing, there are no ABI changes between the two -
-		 * this may need to change if ever ABI-breaking changes are made) */
-		libgamemode = dlopen("libgamemode.so", RTLD_NOW);
-		if (!libgamemode) {
-			snprintf(internal_gamemode_client_error_string,
-			         sizeof(internal_gamemode_client_error_string),
-			         "dlopen failed - %s",
-			         dlerror());
-			internal_libgamemode_loaded = -1;
-			return -1;
-		}
-	}
-
-	/* Attempt to bind all symbols */
-	for (size_t i = 0; i < sizeof(bindings) / sizeof(bindings[0]); i++) {
-		struct binding *binder = &bindings[i];
-
-		if (internal_bind_libgamemode_symbol(libgamemode,
-		                                     binder->name,
-		                                     binder->functor,
-		                                     binder->func_size,
-		                                     binder->required)) {
-			internal_libgamemode_loaded = -1;
-			return -1;
-		};
-	}
-
-	/* Success */
-	internal_libgamemode_loaded = 0;
-	return 0;
-}
-
-/**
- * Redirect to the real libgamemode
- */
-__attribute__((always_inline)) static inline const char *gamemode_error_string(void)
-{
-	/* If we fail to load the system gamemode, or we have an error string already, return our error
-	 * string instead of diverting to the system version */
-	if (internal_load_libgamemode() < 0 || internal_gamemode_client_error_string[0] != '\0') {
-		return internal_gamemode_client_error_string;
-	}
-
-	/* Assert for static analyser that the function is not NULL */
-	assert(REAL_internal_gamemode_error_string != NULL);
-
-	return REAL_internal_gamemode_error_string();
-}
-
-/**
- * Redirect to the real libgamemode
- * Allow automatically requesting game mode
- * Also prints errors as they happen.
- */
-#ifdef GAMEMODE_AUTO
-__attribute__((constructor))
-#else
-__attribute__((always_inline)) static inline
-#endif
-int gamemode_request_start(void)
-{
-	/* Need to load gamemode */
-	if (internal_load_libgamemode() < 0) {
-#ifdef GAMEMODE_AUTO
-		fprintf(stderr, "gamemodeauto: %s\n", gamemode_error_string());
-#endif
-		return -1;
-	}
-
-	/* Assert for static analyser that the function is not NULL */
-	assert(REAL_internal_gamemode_request_start != NULL);
-
-	if (REAL_internal_gamemode_request_start() < 0) {
-#ifdef GAMEMODE_AUTO
-		fprintf(stderr, "gamemodeauto: %s\n", gamemode_error_string());
-#endif
-		return -1;
-	}
-
-	return 0;
-}
-
-/* Redirect to the real libgamemode */
-#ifdef GAMEMODE_AUTO
-__attribute__((destructor))
-#else
-__attribute__((always_inline)) static inline
-#endif
-int gamemode_request_end(void)
-{
-	/* Need to load gamemode */
-	if (internal_load_libgamemode() < 0) {
-#ifdef GAMEMODE_AUTO
-		fprintf(stderr, "gamemodeauto: %s\n", gamemode_error_string());
-#endif
-		return -1;
-	}
-
-	/* Assert for static analyser that the function is not NULL */
-	assert(REAL_internal_gamemode_request_end != NULL);
-
-	if (REAL_internal_gamemode_request_end() < 0) {
-#ifdef GAMEMODE_AUTO
-		fprintf(stderr, "gamemodeauto: %s\n", gamemode_error_string());
-#endif
-		return -1;
-	}
-
-	return 0;
-}
-
-/* Redirect to the real libgamemode */
-__attribute__((always_inline)) static inline int gamemode_query_status(void)
-{
-	/* Need to load gamemode */
-	if (internal_load_libgamemode() < 0) {
-		return -1;
-	}
-
-	if (REAL_internal_gamemode_query_status == NULL) {
-		snprintf(internal_gamemode_client_error_string,
-		         sizeof(internal_gamemode_client_error_string),
-		         "gamemode_query_status missing (older host?)");
-		return -1;
-	}
-
-	return REAL_internal_gamemode_query_status();
-}
-
-/* Redirect to the real libgamemode */
-__attribute__((always_inline)) static inline int gamemode_request_start_for(pid_t pid)
-{
-	/* Need to load gamemode */
-	if (internal_load_libgamemode() < 0) {
-		return -1;
-	}
-
-	if (REAL_internal_gamemode_request_start_for == NULL) {
-		snprintf(internal_gamemode_client_error_string,
-		         sizeof(internal_gamemode_client_error_string),
-		         "gamemode_request_start_for missing (older host?)");
-		return -1;
-	}
-
-	return REAL_internal_gamemode_request_start_for(pid);
-}
-
-/* Redirect to the real libgamemode */
-__attribute__((always_inline)) static inline int gamemode_request_end_for(pid_t pid)
-{
-	/* Need to load gamemode */
-	if (internal_load_libgamemode() < 0) {
-		return -1;
-	}
-
-	if (REAL_internal_gamemode_request_end_for == NULL) {
-		snprintf(internal_gamemode_client_error_string,
-		         sizeof(internal_gamemode_client_error_string),
-		         "gamemode_request_end_for missing (older host?)");
-		return -1;
-	}
-
-	return REAL_internal_gamemode_request_end_for(pid);
-}
-
-/* Redirect to the real libgamemode */
-__attribute__((always_inline)) static inline int gamemode_query_status_for(pid_t pid)
-{
-	/* Need to load gamemode */
-	if (internal_load_libgamemode() < 0) {
-		return -1;
-	}
-
-	if (REAL_internal_gamemode_query_status_for == NULL) {
-		snprintf(internal_gamemode_client_error_string,
-		         sizeof(internal_gamemode_client_error_string),
-		         "gamemode_query_status_for missing (older host?)");
-		return -1;
-	}
-
-	return REAL_internal_gamemode_query_status_for(pid);
-}
-
-#endif // CLIENT_GAMEMODE_H

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/GameHelper.kt

@@ -58,8 +58,8 @@ object GameHelper {
                 gameDirs.removeAt(it - offset)
                 offset++
             }
+            NativeConfig.setGameDirs(gameDirs.toTypedArray())
         }
-        NativeConfig.setGameDirs(gameDirs.toTypedArray())
 
         // Cache list of games found on disk
         val serializedGames = mutableSetOf<String>()

src/common/CMakeLists.txt

@@ -182,15 +182,6 @@ if(ANDROID)
     )
 endif()
 
-if (UNIX AND NOT APPLE)
-  target_sources(common PRIVATE
-    linux/gamemode.cpp
-    linux/gamemode.h
-  )
-
-  target_link_libraries(common PRIVATE gamemode::headers)
-endif()
-
 if(ARCHITECTURE_x86_64)
     target_sources(common
         PRIVATE

src/common/host_memory.cpp

@@ -541,7 +541,7 @@ public:
         if (write) {
             flags |= PROT_WRITE;
         }
-#ifdef HAS_NCE
+#ifdef ARCHITECTURE_arm64
         if (execute) {
             flags |= PROT_EXEC;
         }

src/common/linux/gamemode.cpp

@@ -1,40 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <gamemode_client.h>
-
-#include "common/linux/gamemode.h"
-#include "common/logging/log.h"
-#include "common/settings.h"
-
-namespace Common::Linux {
-
-void StartGamemode() {
-    if (Settings::values.enable_gamemode) {
-        if (gamemode_request_start() < 0) {
-            LOG_WARNING(Frontend, "Failed to start gamemode: {}", gamemode_error_string());
-        } else {
-            LOG_INFO(Frontend, "Started gamemode");
-        }
-    }
-}
-
-void StopGamemode() {
-    if (Settings::values.enable_gamemode) {
-        if (gamemode_request_end() < 0) {
-            LOG_WARNING(Frontend, "Failed to stop gamemode: {}", gamemode_error_string());
-        } else {
-            LOG_INFO(Frontend, "Stopped gamemode");
-        }
-    }
-}
-
-void SetGamemodeState(bool state) {
-    if (state) {
-        StartGamemode();
-    } else {
-        StopGamemode();
-    }
-}
-
-} // namespace Common::Linux

src/common/linux/gamemode.h

@@ -1,24 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-namespace Common::Linux {
-
-/**
- * Start the (Feral Interactive) Linux gamemode if it is installed and it is activated
- */
-void StartGamemode();
-
-/**
- * Stop the (Feral Interactive) Linux gamemode if it is installed and it is activated
- */
-void StopGamemode();
-
-/**
- * Start or stop the (Feral Interactive) Linux gamemode if it is installed and it is activated
- * @param state The new state the gamemode should have
- */
-void SetGamemodeState(bool state);
-
-} // namespace Common::Linux

src/common/settings.cpp

@@ -236,8 +236,6 @@ const char* TranslateCategory(Category category) {
         return "Services";
     case Category::Paths:
         return "Paths";
-    case Category::Linux:
-        return "Linux";
     case Category::MaxEnum:
         break;
     }

src/common/settings.h

@@ -438,9 +438,6 @@ struct Values {
                                                    true,
                                                    true};
 
-    // Linux
-    SwitchableSetting<bool> enable_gamemode{linkage, true, "enable_gamemode", Category::Linux};
-
     // Controls
     InputSetting<std::array<PlayerInput, 10>> players;
 

src/common/settings_common.h

@@ -41,7 +41,6 @@ enum class Category : u32 {
     Multiplayer,
     Services,
     Paths,
-    Linux,
     MaxEnum,
 };
 

src/core/CMakeLists.txt

@@ -935,8 +935,8 @@ if (HAS_NCE)
         arm/nce/arm_nce.h
         arm/nce/arm_nce.s
         arm/nce/guest_context.h
-        arm/nce/patcher.cpp
-        arm/nce/patcher.h
+        arm/nce/patch.cpp
+        arm/nce/patch.h
         arm/nce/instructions.h
     )
     target_link_libraries(core PRIVATE merry::oaknut)

src/core/arm/nce/arm_nce.cpp

@@ -6,7 +6,7 @@
 
 #include "common/signal_chain.h"
 #include "core/arm/nce/arm_nce.h"
-#include "core/arm/nce/patcher.h"
+#include "core/arm/nce/patch.h"
 #include "core/core.h"
 #include "core/memory.h"
 

src/core/arm/nce/patch.cpp

@@ -7,7 +7,7 @@
 #include "core/arm/nce/arm_nce.h"
 #include "core/arm/nce/guest_context.h"
 #include "core/arm/nce/instructions.h"
-#include "core/arm/nce/patcher.h"
+#include "core/arm/nce/patch.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/svc.h"

src/core/hle/service/hid/controllers/touchscreen.cpp

@@ -16,8 +16,7 @@ namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x400;
 
 TouchScreen::TouchScreen(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_)
-    : ControllerBase{hid_core_}, touchscreen_width(Layout::ScreenUndocked::Width),
-      touchscreen_height(Layout::ScreenUndocked::Height) {
+    : ControllerBase{hid_core_} {
     static_assert(SHARED_MEMORY_OFFSET + sizeof(TouchSharedMemory) < shared_memory_size,
                   "TouchSharedMemory is bigger than the shared memory");
     shared_memory = std::construct_at(
@@ -96,8 +95,8 @@ void TouchScreen::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
         if (id < active_fingers_count) {
             const auto& [active_x, active_y] = active_fingers[id].position;
             touch_entry.position = {
-                .x = static_cast<u16>(active_x * static_cast<float>(touchscreen_width)),
-                .y = static_cast<u16>(active_y * static_cast<float>(touchscreen_height)),
+                .x = static_cast<u16>(active_x * Layout::ScreenUndocked::Width),
+                .y = static_cast<u16>(active_y * Layout::ScreenUndocked::Height),
             };
             touch_entry.diameter_x = Settings::values.touchscreen.diameter_x;
             touch_entry.diameter_y = Settings::values.touchscreen.diameter_y;
@@ -121,9 +120,4 @@ void TouchScreen::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
     shared_memory->touch_screen_lifo.WriteNextEntry(next_state);
 }
 
-void TouchScreen::SetTouchscreenDimensions(u32 width, u32 height) {
-    touchscreen_width = width;
-    touchscreen_height = height;
-}
-
 } // namespace Service::HID

src/core/hle/service/hid/controllers/touchscreen.h

@@ -28,8 +28,6 @@ public:
     // When the controller is requesting an update for the shared memory
     void OnUpdate(const Core::Timing::CoreTiming& core_timing) override;
 
-    void SetTouchscreenDimensions(u32 width, u32 height);
-
 private:
     static constexpr std::size_t MAX_FINGERS = 16;
 
@@ -55,7 +53,5 @@ private:
     Core::HID::EmulatedConsole* console = nullptr;
 
     std::array<Core::HID::TouchFinger, MAX_FINGERS> fingers{};
-    u32 touchscreen_width;
-    u32 touchscreen_height;
 };
 } // namespace Service::HID

src/core/hle/service/hid/hid_server.cpp

@@ -208,7 +208,6 @@ IHidServer::IHidServer(Core::System& system_, std::shared_ptr<ResourceManager> r
         {1001, &IHidServer::GetNpadCommunicationMode, "GetNpadCommunicationMode"},
         {1002, &IHidServer::SetTouchScreenConfiguration, "SetTouchScreenConfiguration"},
         {1003, &IHidServer::IsFirmwareUpdateNeededForNotification, "IsFirmwareUpdateNeededForNotification"},
-        {1004, &IHidServer::SetTouchScreenResolution, "SetTouchScreenResolution"},
         {2000, nullptr, "ActivateDigitizer"},
     };
     // clang-format on
@@ -2364,21 +2363,6 @@ void IHidServer::IsFirmwareUpdateNeededForNotification(HLERequestContext& ctx) {
     rb.Push(false);
 }
 
-void IHidServer::SetTouchScreenResolution(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto width{rp.Pop<u32>()};
-    const auto height{rp.Pop<u32>()};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    GetResourceManager()->GetTouchScreen()->SetTouchscreenDimensions(width, height);
-
-    LOG_INFO(Service_HID, "called, width={}, height={}, applet_resource_user_id={}", width, height,
-             applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
 std::shared_ptr<ResourceManager> IHidServer::GetResourceManager() {
     resource_manager->Initialize();
     return resource_manager;

src/core/hle/service/hid/hid_server.h

@@ -141,7 +141,6 @@ private:
     void GetNpadCommunicationMode(HLERequestContext& ctx);
     void SetTouchScreenConfiguration(HLERequestContext& ctx);
     void IsFirmwareUpdateNeededForNotification(HLERequestContext& ctx);
-    void SetTouchScreenResolution(HLERequestContext& ctx);
 
     std::shared_ptr<ResourceManager> resource_manager;
     std::shared_ptr<HidFirmwareSettings> firmware_settings;

src/core/hle/service/set/set_sys.cpp

@@ -34,9 +34,7 @@ Result GetFirmwareVersionImpl(FirmwareVersionFormat& out_firmware, Core::System&
         nca = bis_system->GetEntry(FirmwareVersionSystemDataId, FileSys::ContentRecordType::Data);
     }
     if (nca) {
-        if (auto nca_romfs = nca->GetRomFS(); nca_romfs) {
-            romfs = FileSys::ExtractRomFS(nca_romfs);
-        }
+        romfs = FileSys::ExtractRomFS(nca->GetRomFS());
     }
     if (!romfs) {
         romfs = FileSys::ExtractRomFS(

src/core/loader/deconstructed_rom_directory.cpp

@@ -16,7 +16,7 @@
 #include "core/loader/nso.h"
 
 #ifdef HAS_NCE
-#include "core/arm/nce/patcher.h"
+#include "core/arm/nce/patch.h"
 #endif
 
 namespace Loader {

src/core/loader/nro.cpp

@@ -23,7 +23,7 @@
 #include "core/memory.h"
 
 #ifdef HAS_NCE
-#include "core/arm/nce/patcher.h"
+#include "core/arm/nce/patch.h"
 #endif
 
 namespace Loader {

src/core/loader/nso.cpp

@@ -21,7 +21,7 @@
 #include "core/memory.h"
 
 #ifdef HAS_NCE
-#include "core/arm/nce/patcher.h"
+#include "core/arm/nce/patch.h"
 #endif
 
 namespace Loader {

src/shader_recompiler/backend/glasm/emit_glasm_memory.cpp

@@ -5,7 +5,6 @@
 #include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/frontend/ir/program.h"
 #include "shader_recompiler/frontend/ir/value.h"
-#include "shader_recompiler/profile.h"
 #include "shader_recompiler/runtime_info.h"
 
 namespace Shader::Backend::GLASM {
@@ -36,9 +35,7 @@ void GlobalStorageOp(EmitContext& ctx, Register address, bool pointer_based, std
             continue;
         }
         const auto& ssbo{ctx.info.storage_buffers_descriptors[index]};
-        const u64 ssbo_align_mask{~(ctx.profile.min_ssbo_alignment - 1U)};
-        ctx.Add("LDC.U64 DC.x,c{}[{}];"    // unaligned_ssbo_addr
-                "AND.U64 DC.x,DC.x,{};"    // ssbo_addr = unaligned_ssbo_addr & ssbo_align_mask
+        ctx.Add("LDC.U64 DC.x,c{}[{}];"    // ssbo_addr
                 "LDC.U32 RC.x,c{}[{}];"    // ssbo_size_u32
                 "CVT.U64.U32 DC.y,RC.x;"   // ssbo_size = ssbo_size_u32
                 "ADD.U64 DC.y,DC.y,DC.x;"  // ssbo_end = ssbo_addr + ssbo_size
@@ -47,8 +44,8 @@ void GlobalStorageOp(EmitContext& ctx, Register address, bool pointer_based, std
                 "AND.U.CC RC.x,RC.x,RC.y;" // cond = a && b
                 "IF NE.x;"                 // if cond
                 "SUB.U64 DC.x,{}.x,DC.x;", // offset = input_addr - ssbo_addr
-                ssbo.cbuf_index, ssbo.cbuf_offset, ssbo_align_mask, ssbo.cbuf_index,
-                ssbo.cbuf_offset + 8, address, address, address);
+                ssbo.cbuf_index, ssbo.cbuf_offset, ssbo.cbuf_index, ssbo.cbuf_offset + 8, address,
+                address, address);
         if (pointer_based) {
             ctx.Add("PK64.U DC.y,c[{}];"      // host_ssbo = cbuf
                     "ADD.U64 DC.x,DC.x,DC.y;" // host_addr = host_ssbo + offset

src/shader_recompiler/backend/glsl/glsl_emit_context.cpp

@@ -601,10 +601,7 @@ std::string EmitContext::DefineGlobalMemoryFunctions() {
             addr_xy[i] = fmt::format("ftou({}[{}].{})", cbuf, addr_loc / 16, Swizzle(addr_loc));
             size_xy[i] = fmt::format("ftou({}[{}].{})", cbuf, size_loc / 16, Swizzle(size_loc));
         }
-        const u32 ssbo_align_mask{~(static_cast<u32>(profile.min_ssbo_alignment) - 1U)};
-        const auto aligned_low_addr{fmt::format("{}&{}", addr_xy[0], ssbo_align_mask)};
-        const auto aligned_addr{fmt::format("uvec2({},{})", aligned_low_addr, addr_xy[1])};
-        const auto addr_pack{fmt::format("packUint2x32({})", aligned_addr)};
+        const auto addr_pack{fmt::format("packUint2x32(uvec2({},{}))", addr_xy[0], addr_xy[1])};
         const auto addr_statment{fmt::format("uint64_t {}={};", ssbo_addr, addr_pack)};
         func += addr_statment;
 

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -891,9 +891,7 @@ void EmitContext::DefineGlobalMemoryFunctions(const Info& info) {
             const Id ssbo_size_pointer{OpAccessChain(uniform_types.U32, cbufs[ssbo.cbuf_index].U32,
                                                      zero, ssbo_size_cbuf_offset)};
 
-            const u64 ssbo_align_mask{~(profile.min_ssbo_alignment - 1U)};
-            const Id unaligned_addr{OpBitcast(U64, OpLoad(U32[2], ssbo_addr_pointer))};
-            const Id ssbo_addr{OpBitwiseAnd(U64, unaligned_addr, Constant(U64, ssbo_align_mask))};
+            const Id ssbo_addr{OpBitcast(U64, OpLoad(U32[2], ssbo_addr_pointer))};
             const Id ssbo_size{OpUConvert(U64, OpLoad(U32[1], ssbo_size_pointer))};
             const Id ssbo_end{OpIAdd(U64, ssbo_addr, ssbo_size)};
             const Id cond{OpLogicalAnd(U1, OpUGreaterThanEqual(U1, addr, ssbo_addr),

src/shader_recompiler/frontend/maxwell/translate_program.cpp

@@ -298,7 +298,7 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
 
     Optimization::PositionPass(env, program);
 
-    Optimization::GlobalMemoryToStorageBufferPass(program, host_info);
+    Optimization::GlobalMemoryToStorageBufferPass(program);
     Optimization::TexturePass(env, program, host_info);
 
     if (Settings::values.resolution_info.active) {

src/shader_recompiler/host_translate_info.h

@@ -16,7 +16,6 @@ struct HostTranslateInfo {
     bool needs_demote_reorder{}; ///< True when the device needs DemoteToHelperInvocation reordered
     bool support_snorm_render_buffer{};  ///< True when the device supports SNORM render buffers
     bool support_viewport_index_layer{}; ///< True when the device supports gl_Layer in VS
-    u32 min_ssbo_alignment{};            ///< Minimum alignment supported by the device for SSBOs
     bool support_geometry_shader_passthrough{}; ///< True when the device supports geometry
                                                 ///< passthrough shaders
     bool support_conditional_barrier{}; ///< True when the device supports barriers in conditional

src/shader_recompiler/ir_opt/global_memory_to_storage_buffer_pass.cpp

@@ -11,7 +11,6 @@
 #include "shader_recompiler/frontend/ir/breadth_first_search.h"
 #include "shader_recompiler/frontend/ir/ir_emitter.h"
 #include "shader_recompiler/frontend/ir/value.h"
-#include "shader_recompiler/host_translate_info.h"
 #include "shader_recompiler/ir_opt/passes.h"
 
 namespace Shader::Optimization {
@@ -409,7 +408,7 @@ void CollectStorageBuffers(IR::Block& block, IR::Inst& inst, StorageInfo& info)
 }
 
 /// Returns the offset in indices (not bytes) for an equivalent storage instruction
-IR::U32 StorageOffset(IR::Block& block, IR::Inst& inst, StorageBufferAddr buffer, u32 alignment) {
+IR::U32 StorageOffset(IR::Block& block, IR::Inst& inst, StorageBufferAddr buffer) {
     IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
     IR::U32 offset;
     if (const std::optional<LowAddrInfo> low_addr{TrackLowAddress(&inst)}) {
@@ -422,10 +421,7 @@ IR::U32 StorageOffset(IR::Block& block, IR::Inst& inst, StorageBufferAddr buffer
     }
     // Subtract the least significant 32 bits from the guest offset. The result is the storage
     // buffer offset in bytes.
-    IR::U32 low_cbuf{ir.GetCbuf(ir.Imm32(buffer.index), ir.Imm32(buffer.offset))};
-
-    // Align the offset base to match the host alignment requirements
-    low_cbuf = ir.BitwiseAnd(low_cbuf, ir.Imm32(~(alignment - 1U)));
+    const IR::U32 low_cbuf{ir.GetCbuf(ir.Imm32(buffer.index), ir.Imm32(buffer.offset))};
     return ir.ISub(offset, low_cbuf);
 }
 
@@ -520,7 +516,7 @@ void Replace(IR::Block& block, IR::Inst& inst, const IR::U32& storage_index,
 }
 } // Anonymous namespace
 
-void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateInfo& host_info) {
+void GlobalMemoryToStorageBufferPass(IR::Program& program) {
     StorageInfo info;
     for (IR::Block* const block : program.post_order_blocks) {
         for (IR::Inst& inst : block->Instructions()) {
@@ -544,8 +540,7 @@ void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateIn
         const IR::U32 index{IR::Value{static_cast<u32>(info.set.index_of(it))}};
         IR::Block* const block{storage_inst.block};
         IR::Inst* const inst{storage_inst.inst};
-        const IR::U32 offset{
-            StorageOffset(*block, *inst, storage_buffer, host_info.min_ssbo_alignment)};
+        const IR::U32 offset{StorageOffset(*block, *inst, storage_buffer)};
         Replace(*block, *inst, index, offset);
     }
 }

src/shader_recompiler/ir_opt/passes.h

@@ -16,7 +16,7 @@ void CollectShaderInfoPass(Environment& env, IR::Program& program);
 void ConditionalBarrierPass(IR::Program& program);
 void ConstantPropagationPass(Environment& env, IR::Program& program);
 void DeadCodeEliminationPass(IR::Program& program);
-void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateInfo& host_info);
+void GlobalMemoryToStorageBufferPass(IR::Program& program);
 void IdentityRemovalPass(IR::Program& program);
 void LowerFp64ToFp32(IR::Program& program);
 void LowerFp16ToFp32(IR::Program& program);

src/shader_recompiler/profile.h

@@ -85,8 +85,6 @@ struct Profile {
 
     /// Maxwell and earlier nVidia architectures have broken robust support
     bool has_broken_robust{};
-
-    u64 min_ssbo_alignment{};
 };
 
 } // namespace Shader

src/video_core/buffer_cache/buffer_cache.h

@@ -1753,25 +1753,15 @@ Binding BufferCache<P>::StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
         const u32 memory_layout_size = static_cast<u32>(gpu_memory->GetMemoryLayoutSize(gpu_addr));
         return std::min(memory_layout_size, static_cast<u32>(8_MiB));
     }();
-    // Alignment only applies to the offset of the buffer
-    const u32 alignment = runtime.GetStorageBufferAlignment();
-    const GPUVAddr aligned_gpu_addr = Common::AlignDown(gpu_addr, alignment);
-    const u32 aligned_size = static_cast<u32>(gpu_addr - aligned_gpu_addr) + size;
-
-    const std::optional<VAddr> aligned_cpu_addr = gpu_memory->GpuToCpuAddress(aligned_gpu_addr);
-    if (!aligned_cpu_addr || size == 0) {
+    const std::optional<VAddr> cpu_addr = gpu_memory->GpuToCpuAddress(gpu_addr);
+    if (!cpu_addr || size == 0) {
         LOG_WARNING(HW_GPU, "Failed to find storage buffer for cbuf index {}", cbuf_index);
         return NULL_BINDING;
     }
-    const std::optional<VAddr> cpu_addr = gpu_memory->GpuToCpuAddress(gpu_addr);
-    ASSERT_MSG(cpu_addr, "Unaligned storage buffer address not found for cbuf index {}",
-               cbuf_index);
-    // The end address used for size calculation does not need to be aligned
-    const VAddr cpu_end = Common::AlignUp(*cpu_addr + size, Core::Memory::YUZU_PAGESIZE);
-
+    const VAddr cpu_end = Common::AlignUp(*cpu_addr + size, YUZU_PAGESIZE);
     const Binding binding{
-        .cpu_addr = *aligned_cpu_addr,
-        .size = is_written ? aligned_size : static_cast<u32>(cpu_end - *aligned_cpu_addr),
+        .cpu_addr = *cpu_addr,
+        .size = is_written ? size : static_cast<u32>(cpu_end - *cpu_addr),
         .buffer_id = BufferId{},
     };
     return binding;

src/video_core/buffer_cache/usage_tracker.h

@@ -58,7 +58,7 @@ private:
     void TrackPage(u64 page, u64 offset, u64 size) noexcept {
         const size_t offset_in_page = offset % PAGE_BYTES;
         const size_t first_bit = offset_in_page >> BYTES_PER_BIT_SHIFT;
-        const size_t num_bits = std::min<size_t>(size, PAGE_BYTES) >> BYTES_PER_BIT_SHIFT;
+        const size_t num_bits = std::min(size, PAGE_BYTES) >> BYTES_PER_BIT_SHIFT;
         const size_t mask = ~u64{0} >> (64 - num_bits);
         pages[page] |= (~u64{0} & mask) << first_bit;
     }
@@ -66,7 +66,7 @@ private:
     bool IsPageUsed(u64 page, u64 offset, u64 size) const noexcept {
         const size_t offset_in_page = offset % PAGE_BYTES;
         const size_t first_bit = offset_in_page >> BYTES_PER_BIT_SHIFT;
-        const size_t num_bits = std::min<size_t>(size, PAGE_BYTES) >> BYTES_PER_BIT_SHIFT;
+        const size_t num_bits = std::min(size, PAGE_BYTES) >> BYTES_PER_BIT_SHIFT;
         const size_t mask = ~u64{0} >> (64 - num_bits);
         const size_t mask2 = (~u64{0} & mask) << first_bit;
         return (pages[page] & mask2) != 0;

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -191,10 +191,6 @@ public:
         return device.CanReportMemoryUsage();
     }
 
-    u32 GetStorageBufferAlignment() const {
-        return static_cast<u32>(device.GetShaderStorageBufferAlignment());
-    }
-
 private:
     static constexpr std::array PABO_LUT{
         GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV,          GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV,

src/video_core/renderer_opengl/gl_device.cpp

@@ -265,33 +265,33 @@ std::string Device::GetVendorName() const {
     if (vendor_name == "Intel") {
         // For Mesa, `Intel` is an overloaded vendor string that could mean crocus or iris.
         // Simply return `INTEL` for those as well as the Windows driver.
-        return "Intel";
+        return "INTEL";
     }
     if (vendor_name == "Intel Open Source Technology Center") {
-        return "i965";
+        return "I965";
     }
     if (vendor_name == "Mesa Project") {
-        return "i915";
+        return "I915";
     }
     if (vendor_name == "Mesa/X.org") {
         // This vendor string is overloaded between llvmpipe, softpipe, and virgl, so just return
         // MESA instead of one of those driver names.
-        return "Mesa";
+        return "MESA";
     }
     if (vendor_name == "AMD") {
-        return "RadeonSI";
+        return "RADEONSI";
     }
     if (vendor_name == "nouveau") {
-        return "Nouveau";
+        return "NOUVEAU";
     }
     if (vendor_name == "X.Org") {
         return "R600";
     }
     if (vendor_name == "Collabora Ltd") {
-        return "Zink";
+        return "ZINK";
     }
     if (vendor_name == "Intel Corporation") {
-        return "OpenSWR";
+        return "OPENSWR";
     }
     if (vendor_name == "Microsoft Corporation") {
         return "D3D12";
@@ -300,7 +300,7 @@ std::string Device::GetVendorName() const {
         // Mesa's tegra driver reports `NVIDIA`. Only present in this list because the default
         // strategy would have returned `NVIDIA` here for this driver, the same result as the
         // proprietary driver.
-        return "Tegra";
+        return "TEGRA";
     }
     return vendor_name;
 }

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -232,7 +232,6 @@ ShaderCache::ShaderCache(RasterizerOpenGL& rasterizer_, Core::Frontend::EmuWindo
           .has_gl_bool_ref_bug = device.HasBoolRefBug(),
           .ignore_nan_fp_comparisons = true,
           .gl_max_compute_smem_size = device.GetMaxComputeSharedMemorySize(),
-          .min_ssbo_alignment = device.GetShaderStorageBufferAlignment(),
       },
       host_info{
           .support_float64 = true,
@@ -241,7 +240,6 @@ ShaderCache::ShaderCache(RasterizerOpenGL& rasterizer_, Core::Frontend::EmuWindo
           .needs_demote_reorder = device.IsAmd(),
           .support_snorm_render_buffer = false,
           .support_viewport_index_layer = device.HasVertexViewportLayer(),
-          .min_ssbo_alignment = static_cast<u32>(device.GetShaderStorageBufferAlignment()),
           .support_geometry_shader_passthrough = device.HasGeometryShaderPassthrough(),
           .support_conditional_barrier = device.SupportsConditionalBarriers(),
       } {

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -355,10 +355,6 @@ bool BufferCacheRuntime::CanReportMemoryUsage() const {
     return device.CanReportMemoryUsage();
 }
 
-u32 BufferCacheRuntime::GetStorageBufferAlignment() const {
-    return static_cast<u32>(device.GetStorageBufferAlignment());
-}
-
 void BufferCacheRuntime::TickFrame(VideoCommon::SlotVector<Buffer>& slot_buffers) noexcept {
     for (auto it = slot_buffers.begin(); it != slot_buffers.end(); it++) {
         it->ResetUsageTracking();

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -91,8 +91,6 @@ public:
 
     bool CanReportMemoryUsage() const;
 
-    u32 GetStorageBufferAlignment() const;
-
     [[nodiscard]] StagingBufferRef UploadStagingBuffer(size_t size);
 
     [[nodiscard]] StagingBufferRef DownloadStagingBuffer(size_t size, bool deferred = false);

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -373,7 +373,6 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
             driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
         .has_broken_robust =
             device.IsNvidia() && device.GetNvidiaArch() <= NvidiaArchitecture::Arch_Pascal,
-        .min_ssbo_alignment = device.GetStorageBufferAlignment(),
     };
 
     host_info = Shader::HostTranslateInfo{
@@ -384,7 +383,6 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
             driver_id == VK_DRIVER_ID_AMD_PROPRIETARY || driver_id == VK_DRIVER_ID_AMD_OPEN_SOURCE,
         .support_snorm_render_buffer = true,
         .support_viewport_index_layer = device.IsExtShaderViewportIndexLayerSupported(),
-        .min_ssbo_alignment = static_cast<u32>(device.GetStorageBufferAlignment()),
         .support_geometry_shader_passthrough = device.IsNvGeometryShaderPassthroughSupported(),
         .support_conditional_barrier = device.SupportsConditionalBarriers(),
     };

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -75,20 +75,14 @@ VkViewport GetViewportState(const Device& device, const Maxwell& regs, size_t in
     const float width = conv(src.scale_x * 2.0f);
     float y = conv(src.translate_y - src.scale_y);
     float height = conv(src.scale_y * 2.0f);
+    bool y_negate = regs.window_origin.mode != Maxwell::WindowOrigin::Mode::UpperLeft;
 
-    const bool lower_left = regs.window_origin.mode != Maxwell::WindowOrigin::Mode::UpperLeft;
-    const bool y_negate = !device.IsNvViewportSwizzleSupported() &&
-                          src.swizzle.y == Maxwell::ViewportSwizzle::NegativeY;
-
-    if (lower_left) {
-        // Flip by surface clip height
-        y += conv(static_cast<f32>(regs.surface_clip.height));
-        height = -height;
+    if (!device.IsNvViewportSwizzleSupported()) {
+        y_negate = y_negate != (src.swizzle.y == Maxwell::ViewportSwizzle::NegativeY);
     }
 
     if (y_negate) {
-        // Flip by viewport height
-        y += height;
+        y += conv(static_cast<f32>(regs.surface_clip.height));
         height = -height;
     }
 
@@ -898,6 +892,10 @@ void RasterizerVulkan::UpdateDynamicStates() {
         UpdateFrontFace(regs);
         UpdateStencilOp(regs);
 
+        if (device.IsExtVertexInputDynamicStateSupported()) {
+            UpdateVertexInput(regs);
+        }
+
         if (state_tracker.TouchStateEnable()) {
             UpdateDepthBoundsTestEnable(regs);
             UpdateDepthTestEnable(regs);
@@ -920,9 +918,6 @@ void RasterizerVulkan::UpdateDynamicStates() {
             UpdateBlending(regs);
         }
     }
-    if (device.IsExtVertexInputDynamicStateSupported()) {
-        UpdateVertexInput(regs);
-    }
 }
 
 void RasterizerVulkan::HandleTransformFeedback() {

src/video_core/vulkan_common/vulkan_device.cpp

@@ -519,6 +519,10 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         LOG_WARNING(Render_Vulkan, "ARM drivers have broken VK_EXT_extended_dynamic_state");
         RemoveExtensionFeature(extensions.extended_dynamic_state, features.extended_dynamic_state,
                                VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
+
+        LOG_WARNING(Render_Vulkan, "ARM drivers have broken VK_EXT_extended_dynamic_state2");
+        RemoveExtensionFeature(extensions.extended_dynamic_state2, features.extended_dynamic_state2,
+                               VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
     }
 
     if (is_nvidia) {
@@ -607,12 +611,17 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         }
     }
     if (extensions.vertex_input_dynamic_state && is_qualcomm) {
-        // Qualcomm drivers do not properly support vertex_input_dynamic_state.
-        LOG_WARNING(Render_Vulkan,
-                    "Qualcomm drivers have broken VK_EXT_vertex_input_dynamic_state");
-        RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
-                               features.vertex_input_dynamic_state,
-                               VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+        const u32 version = (properties.properties.driverVersion << 3) >> 3;
+        if (version >= VK_MAKE_API_VERSION(0, 0, 676, 0) &&
+            version < VK_MAKE_API_VERSION(0, 0, 680, 0)) {
+            // Qualcomm Adreno 7xx drivers do not properly support vertex_input_dynamic_state.
+            LOG_WARNING(
+                Render_Vulkan,
+                "Qualcomm Adreno 7xx drivers have broken VK_EXT_vertex_input_dynamic_state");
+            RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
+                                   features.vertex_input_dynamic_state,
+                                   VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+        }
     }
 
     sets_per_pool = 64;
@@ -695,22 +704,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             std::min(properties.properties.limits.maxVertexInputBindings, 16U);
     }
 
-    if (!extensions.extended_dynamic_state && extensions.extended_dynamic_state2) {
-        LOG_INFO(Render_Vulkan,
-                 "Removing extendedDynamicState2 due to missing extendedDynamicState");
-        RemoveExtensionFeature(extensions.extended_dynamic_state2, features.extended_dynamic_state2,
-                               VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
-    }
-
-    if (!extensions.extended_dynamic_state2 && extensions.extended_dynamic_state3) {
-        LOG_INFO(Render_Vulkan,
-                 "Removing extendedDynamicState3 due to missing extendedDynamicState2");
-        RemoveExtensionFeature(extensions.extended_dynamic_state3, features.extended_dynamic_state3,
-                               VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
-        dynamic_state3_blending = false;
-        dynamic_state3_enables = false;
-    }
-
     logical = vk::Device::Create(physical, queue_cis, ExtensionListForVulkan(loaded_extensions),
                                  first_next, dld);
 
@@ -854,41 +847,11 @@ std::string Device::GetDriverName() const {
     case VK_DRIVER_ID_NVIDIA_PROPRIETARY:
         return "NVIDIA";
     case VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS:
-        return "Intel";
+        return "INTEL";
     case VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA:
         return "ANV";
-    case VK_DRIVER_ID_IMAGINATION_PROPRIETARY:
-        return "PowerVR";
-    case VK_DRIVER_ID_QUALCOMM_PROPRIETARY:
-        return "Qualcomm";
-    case VK_DRIVER_ID_ARM_PROPRIETARY:
-        return "Mali";
-    case VK_DRIVER_ID_GOOGLE_SWIFTSHADER:
-        return "SwiftShader";
-    case VK_DRIVER_ID_BROADCOM_PROPRIETARY:
-        return "Broadcom";
     case VK_DRIVER_ID_MESA_LLVMPIPE:
-        return "Lavapipe";
-    case VK_DRIVER_ID_MOLTENVK:
-        return "MoltenVK";
-    case VK_DRIVER_ID_VERISILICON_PROPRIETARY:
-        return "Vivante";
-    case VK_DRIVER_ID_MESA_TURNIP:
-        return "Turnip";
-    case VK_DRIVER_ID_MESA_V3DV:
-        return "V3DV";
-    case VK_DRIVER_ID_MESA_PANVK:
-        return "PanVK";
-    case VK_DRIVER_ID_MESA_VENUS:
-        return "Venus";
-    case VK_DRIVER_ID_MESA_DOZEN:
-        return "Dozen";
-    case VK_DRIVER_ID_MESA_NVK:
-        return "NVK";
-    case VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA:
-        return "PVR";
-    // case VK_DRIVER_ID_MESA_AGXV:
-    //     return "Asahi";
+        return "LAVAPIPE";
     default:
         return properties.driver.driverName;
     }

src/yuzu/configuration/configure_general.cpp

@@ -36,29 +36,12 @@ ConfigureGeneral::~ConfigureGeneral() = default;
 void ConfigureGeneral::SetConfiguration() {}
 
 void ConfigureGeneral::Setup(const ConfigurationShared::Builder& builder) {
-    QLayout& general_layout = *ui->general_widget->layout();
-    QLayout& linux_layout = *ui->linux_widget->layout();
+    QLayout& layout = *ui->general_widget->layout();
 
-    std::map<u32, QWidget*> general_hold{};
-    std::map<u32, QWidget*> linux_hold{};
+    std::map<u32, QWidget*> hold{};
 
-    std::vector<Settings::BasicSetting*> settings;
-
-    auto push = [&settings](auto& list) {
-        for (auto setting : list) {
-            settings.push_back(setting);
-        }
-    };
-
-    push(UISettings::values.linkage.by_category[Settings::Category::UiGeneral]);
-    push(Settings::values.linkage.by_category[Settings::Category::Linux]);
-
-    // Only show Linux group on Unix
-#ifndef __unix__
-    ui->LinuxGroupBox->setVisible(false);
-#endif
-
-    for (const auto setting : settings) {
+    for (const auto setting :
+         UISettings::values.linkage.by_category[Settings::Category::UiGeneral]) {
         auto* widget = builder.BuildWidget(setting, apply_funcs);
 
         if (widget == nullptr) {
@@ -69,23 +52,11 @@ void ConfigureGeneral::Setup(const ConfigurationShared::Builder& builder) {
             continue;
         }
 
-        switch (setting->GetCategory()) {
-        case Settings::Category::UiGeneral:
-            general_hold.emplace(setting->Id(), widget);
-            break;
-        case Settings::Category::Linux:
-            linux_hold.emplace(setting->Id(), widget);
-            break;
-        default:
-            widget->deleteLater();
-        }
+        hold.emplace(setting->Id(), widget);
     }
 
-    for (const auto& [id, widget] : general_hold) {
-        general_layout.addWidget(widget);
-    }
-    for (const auto& [id, widget] : linux_hold) {
-        linux_layout.addWidget(widget);
+    for (const auto& [id, widget] : hold) {
+        layout.addWidget(widget);
     }
 }
 

src/yuzu/configuration/configure_general.ui

@@ -46,33 +46,6 @@
        </layout>
       </widget>
      </item>
-     <item>
-      <widget class="QGroupBox" name="LinuxGroupBox">
-       <property name="title">
-        <string>Linux</string>
-       </property>
-       <layout class="QVBoxLayout" name="LinuxVerticalLayout_1">
-        <item>
-         <widget class="QWidget" name="linux_widget" native="true">
-          <layout class="QVBoxLayout" name="LinuxVerticalLayout_2">
-           <property name="leftMargin">
-            <number>0</number>
-           </property>
-           <property name="topMargin">
-            <number>0</number>
-           </property>
-           <property name="rightMargin">
-            <number>0</number>
-           </property>
-           <property name="bottomMargin">
-            <number>0</number>
-           </property>
-          </layout>
-         </widget>
-        </item>
-       </layout>
-      </widget>
-     </item>
      <item>
       <spacer name="verticalSpacer">
        <property name="orientation">

src/yuzu/configuration/configure_system.ui

@@ -57,7 +57,7 @@
       </widget>
      </item>
      <item>
-      <widget class="QGroupBox" name="coreGroup">
+      <widget class="QGroupBox" name="groupBox">
        <property name="title">
         <string>Core</string>
        </property>

src/yuzu/configuration/shared_translation.cpp

@@ -177,9 +177,6 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QWidget* parent) {
     INSERT(UISettings, controller_applet_disabled, tr("Disable controller applet"),
            QStringLiteral());
 
-    // Linux
-    INSERT(Settings, enable_gamemode, tr("Enable Gamemode"), QStringLiteral());
-
     // Ui Debugging
 
     // Ui Multiplayer

src/yuzu/main.cpp

@@ -17,7 +17,6 @@
 #ifdef __unix__
 #include <csignal>
 #include <sys/socket.h>
-#include "common/linux/gamemode.h"
 #endif
 
 #include <boost/container/flat_set.hpp>
@@ -320,7 +319,6 @@ GMainWindow::GMainWindow(std::unique_ptr<QtConfig> config_, bool has_broken_vulk
       provider{std::make_unique<FileSys::ManualContentProvider>()} {
 #ifdef __unix__
     SetupSigInterrupts();
-    SetGamemodeEnabled(Settings::values.enable_gamemode.GetValue());
 #endif
     system->Initialize();
 
@@ -2122,10 +2120,6 @@ void GMainWindow::OnEmulationStopped() {
 
     discord_rpc->Update();
 
-#ifdef __unix__
-    Common::Linux::StopGamemode();
-#endif
-
     // The emulation is stopped, so closing the window or not does not matter anymore
     disconnect(render_window, &GRenderWindow::Closed, this, &GMainWindow::OnStopGame);
 
@@ -3508,10 +3502,6 @@ void GMainWindow::OnStartGame() {
     play_time_manager->Start();
 
     discord_rpc->Update();
-
-#ifdef __unix__
-    Common::Linux::StartGamemode();
-#endif
 }
 
 void GMainWindow::OnRestartGame() {
@@ -3532,10 +3522,6 @@ void GMainWindow::OnPauseGame() {
     play_time_manager->Stop();
     UpdateMenuState();
     AllowOSSleep();
-
-#ifdef __unix__
-    Common::Linux::StopGamemode();
-#endif
 }
 
 void GMainWindow::OnPauseContinueGame() {
@@ -3817,9 +3803,6 @@ void GMainWindow::OnConfigure() {
     const auto old_theme = UISettings::values.theme;
     const bool old_discord_presence = UISettings::values.enable_discord_presence.GetValue();
     const auto old_language_index = Settings::values.language_index.GetValue();
-#ifdef __unix__
-    const bool old_gamemode = Settings::values.enable_gamemode.GetValue();
-#endif
 
     Settings::SetConfiguringGlobal(true);
     ConfigureDialog configure_dialog(this, hotkey_registry, input_subsystem.get(),
@@ -3881,11 +3864,6 @@ void GMainWindow::OnConfigure() {
     if (UISettings::values.enable_discord_presence.GetValue() != old_discord_presence) {
         SetDiscordEnabled(UISettings::values.enable_discord_presence.GetValue());
     }
-#ifdef __unix__
-    if (Settings::values.enable_gamemode.GetValue() != old_gamemode) {
-        SetGamemodeEnabled(Settings::values.enable_gamemode.GetValue());
-    }
-#endif
 
     if (!multiplayer_state->IsHostingPublicRoom()) {
         multiplayer_state->UpdateCredentials();
@@ -5194,14 +5172,6 @@ void GMainWindow::SetDiscordEnabled([[maybe_unused]] bool state) {
     discord_rpc->Update();
 }
 
-#ifdef __unix__
-void GMainWindow::SetGamemodeEnabled(bool state) {
-    if (emulation_running) {
-        Common::Linux::SetGamemodeState(state);
-    }
-}
-#endif
-
 void GMainWindow::changeEvent(QEvent* event) {
 #ifdef __unix__
     // PaletteChange event appears to only reach so far into the GUI, explicitly asking to

src/yuzu/main.h

@@ -340,7 +340,6 @@ private:
     void SetupSigInterrupts();
     static void HandleSigInterrupt(int);
     void OnSigInterruptNotifierActivated();
-    void SetGamemodeEnabled(bool state);
 #endif
 
 private slots:

src/yuzu_cmd/yuzu.cpp

@@ -63,10 +63,6 @@ __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
 }
 #endif
 
-#ifdef __unix__
-#include "common/linux/gamemode.h"
-#endif
-
 static void PrintHelp(const char* argv0) {
     std::cout << "Usage: " << argv0
               << " [options] <filename>\n"
@@ -429,10 +425,6 @@ int main(int argc, char** argv) {
         exit(0);
     });
 
-#ifdef __unix__
-    Common::Linux::StartGamemode();
-#endif
-
     void(system.Run());
     if (system.DebuggerEnabled()) {
         system.InitializeDebugger();
@@ -444,10 +436,6 @@ int main(int argc, char** argv) {
     void(system.Pause());
     system.ShutdownMainProcess();
 
-#ifdef __unix__
-    Common::Linux::StopGamemode();
-#endif
-
     detached_tasks.WaitForAllTasks();
     return 0;
 }