Merge branch 'shadps4-emu:main' into main

.github/workflows/build.yml

@@ -390,7 +390,7 @@ jobs:
     - name: Cache CMake Configuration
       uses: actions/cache@v4 
       env: 
-          cache-name: ${{ runner.os }}-sdl-cache-cmake-configuration
+          cache-name: ${{ runner.os }}-sdl-gcc-cache-cmake-configuration
       with: 
           path: |  
             ${{github.workspace}}/build 
@@ -401,7 +401,7 @@ jobs:
     - name: Cache CMake Build
       uses: hendrikmuhs/ccache-action@v1.2.14
       env:
-          cache-name: ${{ runner.os }}-sdl-cache-cmake-build
+          cache-name: ${{ runner.os }}-sdl-gcc-cache-cmake-build
       with:
         append-timestamp: false
         key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
@@ -426,7 +426,7 @@ jobs:
     - name: Cache CMake Configuration
       uses: actions/cache@v4 
       env: 
-          cache-name: ${{ runner.os }}-qt-cache-cmake-configuration
+          cache-name: ${{ runner.os }}-qt-gcc-cache-cmake-configuration
       with: 
           path: |  
             ${{github.workspace}}/build 
@@ -437,7 +437,7 @@ jobs:
     - name: Cache CMake Build
       uses: hendrikmuhs/ccache-action@v1.2.14
       env:
-          cache-name: ${{ runner.os }}-qt-cache-cmake-build
+          cache-name: ${{ runner.os }}-qt-gcc-cache-cmake-build
       with:
         append-timestamp: false
         key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}

CMakeLists.txt

@@ -250,6 +250,8 @@ set(KERNEL_LIB src/core/libraries/kernel/sync/mutex.cpp
                src/core/libraries/kernel/time.h
                src/core/libraries/kernel/orbis_error.h
                src/core/libraries/kernel/posix_error.h
+               src/core/libraries/kernel/aio.cpp
+               src/core/libraries/kernel/aio.h
 )
 
 set(NETWORK_LIBS src/core/libraries/network/http.cpp
@@ -430,6 +432,8 @@ set(NP_LIBS src/core/libraries/np_common/np_common.cpp
             src/core/libraries/np_trophy/trophy_ui.cpp
             src/core/libraries/np_trophy/trophy_ui.h
             src/core/libraries/np_trophy/np_trophy_error.h
+            src/core/libraries/np_web_api/np_web_api.cpp
+            src/core/libraries/np_web_api/np_web_api.h
 )
 
 set(MISC_LIBS  src/core/libraries/screenshot/screenshot.cpp
@@ -553,6 +557,16 @@ set(CORE src/core/aerolib/stubs.cpp
          src/core/devices/logger.cpp
          src/core/devices/logger.h
          src/core/devices/nop_device.h
+         src/core/devices/dev_console.cpp
+         src/core/devices/dev_console.h
+         src/core/devices/deci_tty6.cpp
+         src/core/devices/deci_tty6.h
+         src/core/devices/random.cpp
+         src/core/devices/random.h
+         src/core/devices/urandom.cpp
+         src/core/devices/urandom.h
+         src/core/devices/srandom.cpp
+         src/core/devices/srandom.h
          src/core/file_format/pfs.h
          src/core/file_format/pkg.cpp
          src/core/file_format/pkg.h

src/common/adaptive_mutex.h

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#ifdef __linux__
+#include <pthread.h>
+#endif
+
+namespace Common {
+
+#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
+class AdaptiveMutex {
+public:
+    void lock() {
+        pthread_mutex_lock(&mutex);
+    }
+    void unlock() {
+        pthread_mutex_unlock(&mutex);
+    }
+
+private:
+    pthread_mutex_t mutex = PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP;
+};
+#endif // PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
+
+} // namespace Common

src/common/config.cpp

@@ -45,6 +45,8 @@ static std::string logFilter;
 static std::string logType = "async";
 static std::string userName = "shadPS4";
 static std::string updateChannel;
+static u16 deadZoneLeft = 2.0;
+static u16 deadZoneRight = 2.0;
 static std::string backButtonBehavior = "left";
 static bool useSpecialPad = false;
 static int specialPadClass = 1;
@@ -61,9 +63,10 @@ static u32 vblankDivider = 1;
 static bool vkValidation = false;
 static bool vkValidationSync = false;
 static bool vkValidationGpu = false;
-static bool rdocEnable = false;
-static bool vkMarkers = false;
 static bool vkCrashDiagnostic = false;
+static bool vkHostMarkers = false;
+static bool vkGuestMarkers = false;
+static bool rdocEnable = false;
 static s16 cursorState = HideCursorState::Idle;
 static int cursorHideTimeout = 5; // 5 seconds (default)
 static bool separateupdatefolder = false;
@@ -139,6 +142,14 @@ bool getEnableDiscordRPC() {
     return enableDiscordRPC;
 }
 
+u16 leftDeadZone() {
+    return deadZoneLeft;
+}
+
+u16 rightDeadZone() {
+    return deadZoneRight;
+}
+
 s16 getCursorState() {
     return cursorState;
 }
@@ -227,10 +238,6 @@ bool isRdocEnabled() {
     return rdocEnable;
 }
 
-bool isMarkersEnabled() {
-    return vkMarkers;
-}
-
 u32 vblankDiv() {
     return vblankDivider;
 }
@@ -247,14 +254,20 @@ bool vkValidationGpuEnabled() {
     return vkValidationGpu;
 }
 
-bool vkMarkersEnabled() {
-    return vkMarkers || vkCrashDiagnostic; // Crash diagnostic forces markers on
-}
-
 bool vkCrashDiagnosticEnabled() {
     return vkCrashDiagnostic;
 }
 
+bool vkHostMarkersEnabled() {
+    // Forced on when crash diagnostic enabled.
+    return vkHostMarkers || vkCrashDiagnostic;
+}
+
+bool vkGuestMarkersEnabled() {
+    // Forced on when crash diagnostic enabled.
+    return vkGuestMarkers || vkCrashDiagnostic;
+}
+
 bool getSeparateUpdateEnabled() {
     return separateupdatefolder;
 }
@@ -617,6 +630,8 @@ void load(const std::filesystem::path& path) {
     if (data.contains("Input")) {
         const toml::value& input = data.at("Input");
 
+        deadZoneLeft = toml::find_or<float>(input, "deadZoneLeft", 2.0);
+        deadZoneRight = toml::find_or<float>(input, "deadZoneRight", 2.0);
         cursorState = toml::find_or<int>(input, "cursorState", HideCursorState::Idle);
         cursorHideTimeout = toml::find_or<int>(input, "cursorHideTimeout", 5);
         backButtonBehavior = toml::find_or<std::string>(input, "backButtonBehavior", "left");
@@ -644,9 +659,10 @@ void load(const std::filesystem::path& path) {
         vkValidation = toml::find_or<bool>(vk, "validation", false);
         vkValidationSync = toml::find_or<bool>(vk, "validation_sync", false);
         vkValidationGpu = toml::find_or<bool>(vk, "validation_gpu", true);
-        rdocEnable = toml::find_or<bool>(vk, "rdocEnable", false);
-        vkMarkers = toml::find_or<bool>(vk, "rdocMarkersEnable", false);
         vkCrashDiagnostic = toml::find_or<bool>(vk, "crashDiagnostic", false);
+        vkHostMarkers = toml::find_or<bool>(vk, "hostMarkers", false);
+        vkGuestMarkers = toml::find_or<bool>(vk, "guestMarkers", false);
+        rdocEnable = toml::find_or<bool>(vk, "rdocEnable", false);
     }
 
     if (data.contains("Debug")) {
@@ -735,6 +751,8 @@ void save(const std::filesystem::path& path) {
     data["General"]["separateUpdateEnabled"] = separateupdatefolder;
     data["General"]["compatibilityEnabled"] = compatibilityData;
     data["General"]["checkCompatibilityOnStartup"] = checkCompatibilityOnStartup;
+    data["Input"]["deadZoneLeft"] = deadZoneLeft;
+    data["Input"]["deadZoneRight"] = deadZoneRight;
     data["Input"]["cursorState"] = cursorState;
     data["Input"]["cursorHideTimeout"] = cursorHideTimeout;
     data["Input"]["backButtonBehavior"] = backButtonBehavior;
@@ -752,9 +770,10 @@ void save(const std::filesystem::path& path) {
     data["Vulkan"]["validation"] = vkValidation;
     data["Vulkan"]["validation_sync"] = vkValidationSync;
     data["Vulkan"]["validation_gpu"] = vkValidationGpu;
-    data["Vulkan"]["rdocEnable"] = rdocEnable;
-    data["Vulkan"]["rdocMarkersEnable"] = vkMarkers;
     data["Vulkan"]["crashDiagnostic"] = vkCrashDiagnostic;
+    data["Vulkan"]["hostMarkers"] = vkHostMarkers;
+    data["Vulkan"]["guestMarkers"] = vkGuestMarkers;
+    data["Vulkan"]["rdocEnable"] = rdocEnable;
     data["Debug"]["DebugDump"] = isDebugDump;
     data["Debug"]["CollectShader"] = isShaderDebug;
 
@@ -852,9 +871,10 @@ void setDefaultValues() {
     vkValidation = false;
     vkValidationSync = false;
     vkValidationGpu = false;
-    rdocEnable = false;
-    vkMarkers = false;
     vkCrashDiagnostic = false;
+    vkHostMarkers = false;
+    vkGuestMarkers = false;
+    rdocEnable = false;
     emulator_language = "en";
     m_language = 1;
     gpuId = -1;

src/common/config.h

@@ -35,6 +35,8 @@ std::string getLogType();
 std::string getUserName();
 std::string getUpdateChannel();
 
+u16 leftDeadZone();
+u16 rightDeadZone();
 s16 getCursorState();
 int getCursorHideTimeout();
 std::string getBackButtonBehavior();
@@ -100,8 +102,9 @@ void setRdocEnabled(bool enable);
 bool vkValidationEnabled();
 bool vkValidationSyncEnabled();
 bool vkValidationGpuEnabled();
-bool vkMarkersEnabled();
 bool vkCrashDiagnosticEnabled();
+bool vkHostMarkersEnabled();
+bool vkGuestMarkersEnabled();
 
 // Gui
 void setMainWindowGeometry(u32 x, u32 y, u32 w, u32 h);

src/common/logging/filter.cpp

@@ -104,6 +104,7 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
     SUB(Lib, NpManager)                                                                            \
     SUB(Lib, NpScore)                                                                              \
     SUB(Lib, NpTrophy)                                                                             \
+    SUB(Lib, NpWebApi)                                                                             \
     SUB(Lib, Screenshot)                                                                           \
     SUB(Lib, LibCInternal)                                                                         \
     SUB(Lib, AppContent)                                                                           \

src/common/logging/types.h

@@ -71,6 +71,7 @@ enum class Class : u8 {
     Lib_NpManager,         ///< The LibSceNpManager implementation
     Lib_NpScore,           ///< The LibSceNpScore implementation
     Lib_NpTrophy,          ///< The LibSceNpTrophy implementation
+    Lib_NpWebApi,          ///< The LibSceWebApi implementation
     Lib_Screenshot,        ///< The LibSceScreenshot implementation
     Lib_LibCInternal,      ///< The LibCInternal implementation.
     Lib_AppContent,        ///< The LibSceAppContent implementation.

src/common/thread.h

@@ -37,6 +37,10 @@ public:
     void Start();
 
     void End();
+
+    std::chrono::nanoseconds GetTotalWait() const {
+        return total_wait;
+    }
 };
 
 } // namespace Common

src/core/debug_state.h

@@ -131,6 +131,8 @@ class DebugStateImpl {
     friend class Core::Devtools::Widget::FrameGraph;
     friend class Core::Devtools::Widget::ShaderList;
 
+    bool showing_debug_menu_bar = false;
+
     std::queue<std::string> debug_message_popup;
 
     std::mutex guest_threads_mutex{};
@@ -153,6 +155,9 @@ class DebugStateImpl {
     std::vector<ShaderDump> shader_dump_list{};
 
 public:
+    float Framerate = 1.0f / 60.0f;
+    float FrameDeltaTime;
+
     void ShowDebugMessage(std::string message) {
         if (message.empty()) {
             return;
@@ -160,6 +165,10 @@ public:
         debug_message_popup.push(std::move(message));
     }
 
+    bool& IsShowingDebugMenuBar() {
+        return showing_debug_menu_bar;
+    }
+
     void AddCurrentThreadToGuestList();
 
     void RemoveCurrentThreadFromGuestList();

src/core/devices/deci_tty6.cpp

@@ -0,0 +1,66 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/logging/log.h"
+#include "deci_tty6.h"
+
+namespace Core::Devices {
+std::shared_ptr<BaseDevice> DeciTty6Device::Create(u32 handle, const char*, int, u16) {
+    return std::shared_ptr<BaseDevice>(
+        reinterpret_cast<Devices::BaseDevice*>(new DeciTty6Device(handle)));
+}
+int DeciTty6Device::ioctl(u64 cmd, Common::VaCtx* args) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 DeciTty6Device::write(const void* buf, size_t nbytes) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t DeciTty6Device::writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t DeciTty6Device::readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 DeciTty6Device::preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 DeciTty6Device::lseek(s64 offset, int whence) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 DeciTty6Device::read(void* buf, size_t nbytes) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int DeciTty6Device::fstat(Libraries::Kernel::OrbisKernelStat* sb) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s32 DeciTty6Device::fsync() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int DeciTty6Device::ftruncate(s64 length) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int DeciTty6Device::getdents(void* buf, u32 nbytes, s64* basep) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 DeciTty6Device::pwrite(const void* buf, size_t nbytes, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+} // namespace Core::Devices

src/core/devices/deci_tty6.h

@@ -0,0 +1,33 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+#include <memory>
+#include "base_device.h"
+
+namespace Core::Devices {
+
+class DeciTty6Device final : BaseDevice {
+    u32 handle;
+
+public:
+    static std::shared_ptr<BaseDevice> Create(u32 handle, const char*, int, u16);
+    explicit DeciTty6Device(u32 handle) : handle(handle) {}
+
+    ~DeciTty6Device() override = default;
+
+    int ioctl(u64 cmd, Common::VaCtx* args) override;
+    s64 write(const void* buf, size_t nbytes) override;
+    size_t readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    size_t writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    s64 preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) override;
+    s64 lseek(s64 offset, int whence) override;
+    s64 read(void* buf, size_t nbytes) override;
+    int fstat(Libraries::Kernel::OrbisKernelStat* sb) override;
+    s32 fsync() override;
+    int ftruncate(s64 length) override;
+    int getdents(void* buf, u32 nbytes, s64* basep) override;
+    s64 pwrite(const void* buf, size_t nbytes, u64 offset) override;
+};
+
+} // namespace Core::Devices

src/core/devices/dev_console.cpp

@@ -0,0 +1,67 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/logging/log.h"
+#include "dev_console.h"
+
+namespace Core::Devices {
+std::shared_ptr<BaseDevice> ConsoleDevice::Create(u32 handle, const char*, int, u16) {
+    return std::shared_ptr<BaseDevice>(
+        reinterpret_cast<Devices::BaseDevice*>(new ConsoleDevice(handle)));
+}
+int ConsoleDevice::ioctl(u64 cmd, Common::VaCtx* args) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 ConsoleDevice::write(const void* buf, size_t nbytes) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t ConsoleDevice::writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t ConsoleDevice::readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 ConsoleDevice::preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 ConsoleDevice::lseek(s64 offset, int whence) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 ConsoleDevice::read(void* buf, size_t nbytes) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int ConsoleDevice::fstat(Libraries::Kernel::OrbisKernelStat* sb) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s32 ConsoleDevice::fsync() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int ConsoleDevice::ftruncate(s64 length) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int ConsoleDevice::getdents(void* buf, u32 nbytes, s64* basep) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 ConsoleDevice::pwrite(const void* buf, size_t nbytes, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+} // namespace Core::Devices

src/core/devices/dev_console.h

@@ -0,0 +1,33 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+#include <memory>
+#include "base_device.h"
+
+namespace Core::Devices {
+
+class ConsoleDevice final : BaseDevice {
+    u32 handle;
+
+public:
+    static std::shared_ptr<BaseDevice> Create(u32 handle, const char*, int, u16);
+    explicit ConsoleDevice(u32 handle) : handle(handle) {}
+
+    ~ConsoleDevice() override = default;
+
+    int ioctl(u64 cmd, Common::VaCtx* args) override;
+    s64 write(const void* buf, size_t nbytes) override;
+    size_t readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    size_t writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    s64 preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) override;
+    s64 lseek(s64 offset, int whence) override;
+    s64 read(void* buf, size_t nbytes) override;
+    int fstat(Libraries::Kernel::OrbisKernelStat* sb) override;
+    s32 fsync() override;
+    int ftruncate(s64 length) override;
+    int getdents(void* buf, u32 nbytes, s64* basep) override;
+    s64 pwrite(const void* buf, size_t nbytes, u64 offset) override;
+};
+
+} // namespace Core::Devices

src/core/devices/random.cpp

@@ -0,0 +1,68 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+#include <cstdlib>
+#include "common/logging/log.h"
+#include "random.h"
+
+namespace Core::Devices {
+std::shared_ptr<BaseDevice> RandomDevice::Create(u32 handle, const char*, int, u16) {
+    std::srand(std::time(nullptr));
+    return std::shared_ptr<BaseDevice>(
+        reinterpret_cast<Devices::BaseDevice*>(new RandomDevice(handle)));
+}
+int RandomDevice::ioctl(u64 cmd, Common::VaCtx* args) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 RandomDevice::write(const void* buf, size_t nbytes) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t RandomDevice::writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t RandomDevice::readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 RandomDevice::preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 RandomDevice::lseek(s64 offset, int whence) {
+    return 0;
+}
+
+s64 RandomDevice::read(void* buf, size_t nbytes) {
+    auto rbuf = static_cast<char*>(buf);
+    for (size_t i = 0; i < nbytes; i++)
+        rbuf[i] = std::rand() & 0xFF;
+    return nbytes;
+}
+
+int RandomDevice::fstat(Libraries::Kernel::OrbisKernelStat* sb) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s32 RandomDevice::fsync() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int RandomDevice::ftruncate(s64 length) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int RandomDevice::getdents(void* buf, u32 nbytes, s64* basep) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 RandomDevice::pwrite(const void* buf, size_t nbytes, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+} // namespace Core::Devices

src/core/devices/random.h

@@ -0,0 +1,33 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+#include <memory>
+#include "base_device.h"
+
+namespace Core::Devices {
+
+class RandomDevice final : BaseDevice {
+    u32 handle;
+
+public:
+    static std::shared_ptr<BaseDevice> Create(u32 handle, const char*, int, u16);
+    explicit RandomDevice(u32 handle) : handle(handle) {}
+
+    ~RandomDevice() override = default;
+
+    int ioctl(u64 cmd, Common::VaCtx* args) override;
+    s64 write(const void* buf, size_t nbytes) override;
+    size_t readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    size_t writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    s64 preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) override;
+    s64 lseek(s64 offset, int whence) override;
+    s64 read(void* buf, size_t nbytes) override;
+    int fstat(Libraries::Kernel::OrbisKernelStat* sb) override;
+    s32 fsync() override;
+    int ftruncate(s64 length) override;
+    int getdents(void* buf, u32 nbytes, s64* basep) override;
+    s64 pwrite(const void* buf, size_t nbytes, u64 offset) override;
+};
+
+} // namespace Core::Devices

src/core/devices/srandom.cpp

@@ -0,0 +1,69 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+#include <cstdlib>
+#include "common/logging/log.h"
+#include "srandom.h"
+
+namespace Core::Devices {
+std::shared_ptr<BaseDevice> SRandomDevice::Create(u32 handle, const char*, int, u16) {
+    std::srand(std::time(nullptr));
+    return std::shared_ptr<BaseDevice>(
+        reinterpret_cast<Devices::BaseDevice*>(new SRandomDevice(handle)));
+}
+int SRandomDevice::ioctl(u64 cmd, Common::VaCtx* args) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 SRandomDevice::write(const void* buf, size_t nbytes) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t SRandomDevice::writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t SRandomDevice::readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 SRandomDevice::preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 SRandomDevice::lseek(s64 offset, int whence) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 SRandomDevice::read(void* buf, size_t nbytes) {
+    auto rbuf = static_cast<char*>(buf);
+    for (size_t i = 0; i < nbytes; i++)
+        rbuf[i] = std::rand();
+    return nbytes;
+}
+
+int SRandomDevice::fstat(Libraries::Kernel::OrbisKernelStat* sb) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s32 SRandomDevice::fsync() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return s32();
+}
+
+int SRandomDevice::ftruncate(s64 length) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int SRandomDevice::getdents(void* buf, u32 nbytes, s64* basep) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 SRandomDevice::pwrite(const void* buf, size_t nbytes, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+} // namespace Core::Devices

src/core/devices/srandom.h

@@ -0,0 +1,33 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+#include <memory>
+#include "base_device.h"
+
+namespace Core::Devices {
+
+class SRandomDevice final : BaseDevice {
+    u32 handle;
+
+public:
+    static std::shared_ptr<BaseDevice> Create(u32 handle, const char*, int, u16);
+    explicit SRandomDevice(u32 handle) : handle(handle) {}
+
+    ~SRandomDevice() override = default;
+
+    int ioctl(u64 cmd, Common::VaCtx* args) override;
+    s64 write(const void* buf, size_t nbytes) override;
+    size_t readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    size_t writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    s64 preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) override;
+    s64 lseek(s64 offset, int whence) override;
+    s64 read(void* buf, size_t nbytes) override;
+    int fstat(Libraries::Kernel::OrbisKernelStat* sb) override;
+    s32 fsync() override;
+    int ftruncate(s64 length) override;
+    int getdents(void* buf, u32 nbytes, s64* basep) override;
+    s64 pwrite(const void* buf, size_t nbytes, u64 offset) override;
+};
+
+} // namespace Core::Devices

src/core/devices/urandom.cpp

@@ -0,0 +1,71 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+#include <cstdlib>
+#include "common/logging/log.h"
+#include "urandom.h"
+
+namespace Core::Devices {
+
+std::shared_ptr<BaseDevice> URandomDevice::Create(u32 handle, const char*, int, u16) {
+    std::srand(std::time(nullptr));
+    return std::shared_ptr<BaseDevice>(
+        reinterpret_cast<Devices::BaseDevice*>(new URandomDevice(handle)));
+}
+
+int URandomDevice::ioctl(u64 cmd, Common::VaCtx* args) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 URandomDevice::write(const void* buf, size_t nbytes) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t URandomDevice::writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+size_t URandomDevice::readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 URandomDevice::preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+s64 URandomDevice::lseek(s64 offset, int whence) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 URandomDevice::read(void* buf, size_t nbytes) {
+    auto rbuf = static_cast<char*>(buf);
+    for (size_t i = 0; i < nbytes; i++)
+        rbuf[i] = std::rand() & 0xFF;
+    return nbytes;
+}
+
+int URandomDevice::fstat(Libraries::Kernel::OrbisKernelStat* sb) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s32 URandomDevice::fsync() {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int URandomDevice::ftruncate(s64 length) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+int URandomDevice::getdents(void* buf, u32 nbytes, s64* basep) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+
+s64 URandomDevice::pwrite(const void* buf, size_t nbytes, u64 offset) {
+    LOG_ERROR(Kernel_Pthread, "(STUBBED) called");
+    return 0;
+}
+} // namespace Core::Devices

src/core/devices/urandom.h

@@ -0,0 +1,33 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+#include <memory>
+#include "base_device.h"
+
+namespace Core::Devices {
+
+class URandomDevice final : BaseDevice {
+    u32 handle;
+
+public:
+    static std::shared_ptr<BaseDevice> Create(u32 handle, const char*, int, u16);
+    explicit URandomDevice(u32 handle) : handle(handle) {}
+
+    ~URandomDevice() override = default;
+
+    int ioctl(u64 cmd, Common::VaCtx* args) override;
+    s64 write(const void* buf, size_t nbytes) override;
+    size_t readv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    size_t writev(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt) override;
+    s64 preadv(const Libraries::Kernel::SceKernelIovec* iov, int iovcnt, u64 offset) override;
+    s64 lseek(s64 offset, int whence) override;
+    s64 read(void* buf, size_t nbytes) override;
+    int fstat(Libraries::Kernel::OrbisKernelStat* sb) override;
+    s32 fsync() override;
+    int ftruncate(s64 length) override;
+    int getdents(void* buf, u32 nbytes, s64* basep) override;
+    s64 pwrite(const void* buf, size_t nbytes, u64 offset) override;
+};
+
+} // namespace Core::Devices

src/core/devtools/layer.cpp

@@ -28,7 +28,6 @@ static bool show_simple_fps = false;
 static bool visibility_toggled = false;
 
 static float fps_scale = 1.0f;
-static bool show_advanced_debug = false;
 static int dump_frame_count = 1;
 
 static Widget::FrameGraph frame_graph;
@@ -94,6 +93,12 @@ void L::DrawMenuBar() {
             }
             ImGui::EndMenu();
         }
+
+        SameLine(ImGui::GetWindowWidth() - 30.0f);
+        if (Button("X", ImVec2(25, 25))) {
+            DebugState.IsShowingDebugMenuBar() = false;
+        }
+
         EndMainMenuBar();
     }
 
@@ -253,8 +258,8 @@ void L::DrawAdvanced() {
 }
 
 void L::DrawSimple() {
-    const auto io = GetIO();
-    Text("%.1f FPS (%.2f ms)", io.Framerate, 1000.0f / io.Framerate);
+    const float frameRate = DebugState.Framerate;
+    Text("%d FPS (%.1f ms)", static_cast<int>(std::round(frameRate)), 1000.0f / frameRate);
 }
 
 static void LoadSettings(const char* line) {
@@ -265,7 +270,7 @@ static void LoadSettings(const char* line) {
         return;
     }
     if (sscanf(line, "show_advanced_debug=%d", &i) == 1) {
-        show_advanced_debug = i != 0;
+        DebugState.IsShowingDebugMenuBar() = i != 0;
         return;
     }
     if (sscanf(line, "show_frame_graph=%d", &i) == 1) {
@@ -310,7 +315,7 @@ void L::SetupSettings() {
     handler.WriteAllFn = [](ImGuiContext*, ImGuiSettingsHandler* handler, ImGuiTextBuffer* buf) {
         buf->appendf("[%s][Data]\n", handler->TypeName);
         buf->appendf("fps_scale=%f\n", fps_scale);
-        buf->appendf("show_advanced_debug=%d\n", show_advanced_debug);
+        buf->appendf("show_advanced_debug=%d\n", DebugState.IsShowingDebugMenuBar());
         buf->appendf("show_frame_graph=%d\n", frame_graph.is_open);
         buf->appendf("dump_frame_count=%d\n", dump_frame_count);
         buf->append("\n");
@@ -336,12 +341,12 @@ void L::Draw() {
 
     if (!DebugState.IsGuestThreadsPaused()) {
         const auto fn = DebugState.flip_frame_count.load();
-        frame_graph.AddFrame(fn, io.DeltaTime);
+        frame_graph.AddFrame(fn, DebugState.FrameDeltaTime);
     }
 
     if (IsKeyPressed(ImGuiKey_F10, false)) {
         if (io.KeyCtrl) {
-            show_advanced_debug = !show_advanced_debug;
+            DebugState.IsShowingDebugMenuBar() ^= true;
         } else {
             show_simple_fps = !show_simple_fps;
         }
@@ -376,7 +381,7 @@ void L::Draw() {
         End();
     }
 
-    if (show_advanced_debug) {
+    if (DebugState.IsShowingDebugMenuBar()) {
         PushFont(io.Fonts->Fonts[IMGUI_FONT_MONO]);
         PushID("DevtoolsLayer");
         DrawAdvanced();

src/core/devtools/widget/frame_graph.cpp

@@ -83,15 +83,13 @@ void FrameGraph::Draw() {
 
         auto isSystemPaused = DebugState.IsGuestThreadsPaused();
 
-        static float deltaTime;
-        static float frameRate;
-
         if (!isSystemPaused) {
-            deltaTime = io.DeltaTime * 1000.0f;
+            deltaTime = DebugState.FrameDeltaTime * 1000.0f;
             frameRate = 1000.0f / deltaTime;
         }
 
         Text("Frame time: %.3f ms (%.1f FPS)", deltaTime, frameRate);
+        Text("Presenter time: %.3f ms (%.1f FPS)", io.DeltaTime * 1000.0f, 1.0f / io.DeltaTime);
         Text("Flip frame: %d Gnm submit frame: %d", DebugState.flip_frame_count.load(),
              DebugState.gnm_frame_count.load());
 

src/core/devtools/widget/frame_graph.h

@@ -16,6 +16,9 @@ class FrameGraph {
 
     std::array<FrameInfo, FRAME_BUFFER_SIZE> frame_list{};
 
+    float deltaTime{};
+    float frameRate{};
+
     void DrawFrameGraph();
 
 public:

src/core/libraries/kernel/aio.cpp

@@ -0,0 +1,339 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <thread>
+
+#include "aio.h"
+#include "common/assert.h"
+#include "common/debug.h"
+#include "common/logging/log.h"
+#include "core/libraries/kernel/equeue.h"
+#include "core/libraries/kernel/orbis_error.h"
+#include "core/libraries/libs.h"
+#include "file_system.h"
+
+namespace Libraries::Kernel {
+
+#define MAX_QUEUE 512
+
+static s32* id_state;
+static s32 id_index;
+
+s32 sceKernelAioInitializeImpl(void* p, s32 size) {
+
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioDeleteRequest(OrbisKernelAioSubmitId id, s32* ret) {
+    if (ret == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    id_state[id] = ORBIS_KERNEL_AIO_STATE_ABORTED;
+    *ret = 0;
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioDeleteRequests(OrbisKernelAioSubmitId id[], s32 num, s32 ret[]) {
+    if (ret == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    for (s32 i = 0; i < num; i++) {
+        id_state[id[i]] = ORBIS_KERNEL_AIO_STATE_ABORTED;
+        ret[i] = 0;
+    }
+
+    return 0;
+}
+s32 PS4_SYSV_ABI sceKernelAioPollRequest(OrbisKernelAioSubmitId id, s32* state) {
+    if (state == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    *state = id_state[id];
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioPollRequests(OrbisKernelAioSubmitId id[], s32 num, s32 state[]) {
+    if (state == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    for (s32 i = 0; i < num; i++) {
+        state[i] = id_state[id[i]];
+    }
+
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioCancelRequest(OrbisKernelAioSubmitId id, s32* state) {
+    if (state == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    if (id) {
+        id_state[id] = ORBIS_KERNEL_AIO_STATE_ABORTED;
+        *state = ORBIS_KERNEL_AIO_STATE_ABORTED;
+    } else {
+        *state = ORBIS_KERNEL_AIO_STATE_PROCESSING;
+    }
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioCancelRequests(OrbisKernelAioSubmitId id[], s32 num, s32 state[]) {
+    if (state == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    for (s32 i = 0; i < num; i++) {
+        if (id[i]) {
+            id_state[id[i]] = ORBIS_KERNEL_AIO_STATE_ABORTED;
+            state[i] = ORBIS_KERNEL_AIO_STATE_ABORTED;
+        } else {
+            state[i] = ORBIS_KERNEL_AIO_STATE_PROCESSING;
+        }
+    }
+
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioWaitRequest(OrbisKernelAioSubmitId id, s32* state, u32* usec) {
+    if (state == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    u32 timer = 0;
+
+    s32 timeout = 0;
+
+    while (id_state[id] == ORBIS_KERNEL_AIO_STATE_PROCESSING) {
+        sceKernelUsleep(10);
+
+        timer += 10;
+        if (*usec) {
+            if (timer > *usec) {
+                timeout = 1;
+                break;
+            }
+        }
+    }
+
+    *state = id_state[id];
+
+    if (timeout)
+        return ORBIS_KERNEL_ERROR_ETIMEDOUT;
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioWaitRequests(OrbisKernelAioSubmitId id[], s32 num, s32 state[],
+                                          u32 mode, u32* usec) {
+    if (state == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    u32 timer = 0;
+    s32 timeout = 0;
+    s32 completion = 0;
+
+    for (s32 i = 0; i < num; i++) {
+        if (!completion && !timeout) {
+            while (id_state[id[i]] == ORBIS_KERNEL_AIO_STATE_PROCESSING) {
+                sceKernelUsleep(10);
+                timer += 10;
+
+                if (*usec) {
+                    if (timer > *usec) {
+                        timeout = 1;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (mode == 0x02) {
+            if (id_state[id[i]] == ORBIS_KERNEL_AIO_STATE_COMPLETED)
+                completion = 1;
+        }
+
+        state[i] = id_state[id[i]];
+    }
+
+    if (timeout)
+        return ORBIS_KERNEL_ERROR_ETIMEDOUT;
+
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioSubmitReadCommands(OrbisKernelAioRWRequest req[], s32 size, s32 prio,
+                                                OrbisKernelAioSubmitId* id) {
+    if (req == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    if (id == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    id_state[id_index] = ORBIS_KERNEL_AIO_STATE_PROCESSING;
+
+    for (s32 i = 0; i < size; i++) {
+
+        s64 ret = sceKernelPread(req[i].fd, req[i].buf, req[i].nbyte, req[i].offset);
+
+        if (ret < 0) {
+            req[i].result->state = ORBIS_KERNEL_AIO_STATE_ABORTED;
+            req[i].result->returnValue = ret;
+
+        } else {
+            req[i].result->state = ORBIS_KERNEL_AIO_STATE_COMPLETED;
+            req[i].result->returnValue = ret;
+        }
+    }
+
+    id_state[id_index] = ORBIS_KERNEL_AIO_STATE_COMPLETED;
+
+    *id = id_index;
+
+    id_index = (id_index + 1) % MAX_QUEUE;
+
+    if (!id_index)
+        id_index++;
+
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioSubmitReadCommandsMultiple(OrbisKernelAioRWRequest req[], s32 size,
+                                                        s32 prio, OrbisKernelAioSubmitId id[]) {
+    if (req == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    if (id == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    for (s32 i = 0; i < size; i++) {
+        id_state[id_index] = ORBIS_KERNEL_AIO_STATE_PROCESSING;
+
+        s64 ret = sceKernelPread(req[i].fd, req[i].buf, req[i].nbyte, req[i].offset);
+
+        if (ret < 0) {
+            req[i].result->state = ORBIS_KERNEL_AIO_STATE_ABORTED;
+            req[i].result->returnValue = ret;
+
+            id_state[id_index] = ORBIS_KERNEL_AIO_STATE_ABORTED;
+
+        } else {
+            req[i].result->state = ORBIS_KERNEL_AIO_STATE_COMPLETED;
+            req[i].result->returnValue = ret;
+
+            id_state[id_index] = ORBIS_KERNEL_AIO_STATE_COMPLETED;
+        }
+
+        id[i] = id_index;
+
+        id_index = (id_index + 1) % MAX_QUEUE;
+
+        if (!id_index)
+            id_index++;
+    }
+
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioSubmitWriteCommands(OrbisKernelAioRWRequest req[], s32 size, s32 prio,
+                                                 OrbisKernelAioSubmitId* id) {
+    if (req == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    if (id == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    for (s32 i = 0; i < size; i++) {
+        id_state[id_index] = ORBIS_KERNEL_AIO_STATE_PROCESSING;
+
+        s64 ret = sceKernelPwrite(req[i].fd, req[i].buf, req[i].nbyte, req[i].offset);
+
+        if (ret < 0) {
+            req[i].result->state = ORBIS_KERNEL_AIO_STATE_ABORTED;
+            req[i].result->returnValue = ret;
+
+            id_state[id_index] = ORBIS_KERNEL_AIO_STATE_ABORTED;
+
+        } else {
+            req[i].result->state = ORBIS_KERNEL_AIO_STATE_COMPLETED;
+            req[i].result->returnValue = ret;
+
+            id_state[id_index] = ORBIS_KERNEL_AIO_STATE_COMPLETED;
+        }
+    }
+
+    *id = id_index;
+
+    id_index = (id_index + 1) % MAX_QUEUE;
+
+    // skip id_index equals 0 , because sceKernelAioCancelRequest will submit id
+    // equal to 0
+    if (!id_index)
+        id_index++;
+
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioSubmitWriteCommandsMultiple(OrbisKernelAioRWRequest req[], s32 size,
+                                                         s32 prio, OrbisKernelAioSubmitId id[]) {
+    if (req == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    if (id == nullptr) {
+        return ORBIS_KERNEL_ERROR_EFAULT;
+    }
+    for (s32 i = 0; i < size; i++) {
+        id_state[id_index] = ORBIS_KERNEL_AIO_STATE_PROCESSING;
+        s64 ret = sceKernelPwrite(req[i].fd, req[i].buf, req[i].nbyte, req[i].offset);
+
+        if (ret < 0) {
+            req[i].result->state = ORBIS_KERNEL_AIO_STATE_ABORTED;
+            req[i].result->returnValue = ret;
+
+            id_state[id_index] = ORBIS_KERNEL_AIO_STATE_ABORTED;
+
+        } else {
+            req[i].result->state = ORBIS_KERNEL_AIO_STATE_COMPLETED;
+            req[i].result->returnValue = ret;
+            id_state[id_index] = ORBIS_KERNEL_AIO_STATE_COMPLETED;
+        }
+
+        id[i] = id_index;
+        id_index = (id_index + 1) % MAX_QUEUE;
+
+        if (!id_index)
+            id_index++;
+    }
+    return 0;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioSetParam() {
+    LOG_ERROR(Kernel, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceKernelAioInitializeParam() {
+    LOG_ERROR(Kernel, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterAio(Core::Loader::SymbolsResolver* sym) {
+    id_index = 1;
+    id_state = (int*)malloc(sizeof(int) * MAX_QUEUE);
+    memset(id_state, 0, sizeof(sizeof(int) * MAX_QUEUE));
+
+    LIB_FUNCTION("fR521KIGgb8", "libkernel", 1, "libkernel", 1, 1, sceKernelAioCancelRequest);
+    LIB_FUNCTION("3Lca1XBrQdY", "libkernel", 1, "libkernel", 1, 1, sceKernelAioCancelRequests);
+    LIB_FUNCTION("5TgME6AYty4", "libkernel", 1, "libkernel", 1, 1, sceKernelAioDeleteRequest);
+    LIB_FUNCTION("Ft3EtsZzAoY", "libkernel", 1, "libkernel", 1, 1, sceKernelAioDeleteRequests);
+    LIB_FUNCTION("vYU8P9Td2Zo", "libkernel", 1, "libkernel", 1, 1, sceKernelAioInitializeImpl);
+    LIB_FUNCTION("nu4a0-arQis", "libkernel", 1, "libkernel", 1, 1, sceKernelAioInitializeParam);
+    LIB_FUNCTION("2pOuoWoCxdk", "libkernel", 1, "libkernel", 1, 1, sceKernelAioPollRequest);
+    LIB_FUNCTION("o7O4z3jwKzo", "libkernel", 1, "libkernel", 1, 1, sceKernelAioPollRequests);
+    LIB_FUNCTION("9WK-vhNXimw", "libkernel", 1, "libkernel", 1, 1, sceKernelAioSetParam);
+    LIB_FUNCTION("HgX7+AORI58", "libkernel", 1, "libkernel", 1, 1, sceKernelAioSubmitReadCommands);
+    LIB_FUNCTION("lXT0m3P-vs4", "libkernel", 1, "libkernel", 1, 1,
+                 sceKernelAioSubmitReadCommandsMultiple);
+    LIB_FUNCTION("XQ8C8y+de+E", "libkernel", 1, "libkernel", 1, 1, sceKernelAioSubmitWriteCommands);
+    LIB_FUNCTION("xT3Cpz0yh6Y", "libkernel", 1, "libkernel", 1, 1,
+                 sceKernelAioSubmitWriteCommandsMultiple);
+    LIB_FUNCTION("KOF-oJbQVvc", "libkernel", 1, "libkernel", 1, 1, sceKernelAioWaitRequest);
+    LIB_FUNCTION("lgK+oIWkJyA", "libkernel", 1, "libkernel", 1, 1, sceKernelAioWaitRequests);
+}
+
+} // namespace Libraries::Kernel

src/core/libraries/kernel/aio.h

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <condition_variable>
+#include <mutex>
+#include <string>
+#include <vector>
+#include <boost/asio/steady_timer.hpp>
+
+#include "common/types.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
+
+namespace Libraries::Kernel {
+
+enum AioState {
+    ORBIS_KERNEL_AIO_STATE_SUBMITTED = 1,
+    ORBIS_KERNEL_AIO_STATE_PROCESSING = 2,
+    ORBIS_KERNEL_AIO_STATE_COMPLETED = 3,
+    ORBIS_KERNEL_AIO_STATE_ABORTED = 4
+};
+
+struct OrbisKernelAioResult {
+    s64 returnValue;
+    u32 state;
+};
+
+typedef s32 OrbisKernelAioSubmitId;
+
+struct OrbisKernelAioRWRequest {
+    s64 offset;
+    s64 nbyte;
+    void* buf;
+    OrbisKernelAioResult* result;
+    s32 fd;
+};
+
+void RegisterAio(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::Kernel

src/core/libraries/kernel/file_system.cpp

@@ -8,8 +8,13 @@
 #include "common/logging/log.h"
 #include "common/scope_exit.h"
 #include "common/singleton.h"
+#include "core/devices/deci_tty6.h"
+#include "core/devices/dev_console.h"
 #include "core/devices/logger.h"
 #include "core/devices/nop_device.h"
+#include "core/devices/random.h"
+#include "core/devices/srandom.h"
+#include "core/devices/urandom.h"
 #include "core/file_sys/fs.h"
 #include "core/libraries/kernel/file_system.h"
 #include "core/libraries/kernel/orbis_error.h"
@@ -41,6 +46,12 @@ static std::map<std::string, FactoryDevice> available_device = {
     {"/dev/deci_stderr", GET_DEVICE_FD(2)},
 
     {"/dev/null", GET_DEVICE_FD(0)}, // fd0 (stdin) is a nop device
+
+    {"/dev/urandom",  &D::URandomDevice::Create },
+    {"/dev/random",   &D::RandomDevice::Create },
+    {"/dev/srandom",  &D::SRandomDevice::Create },
+    {"/dev/console",  &D::ConsoleDevice::Create },
+    {"/dev/deci_tty6",&D::DeciTty6Device::Create }
     // clang-format on
 };
 
@@ -67,17 +78,6 @@ int PS4_SYSV_ABI sceKernelOpen(const char* raw_path, int flags, u16 mode) {
     bool directory = (flags & ORBIS_KERNEL_O_DIRECTORY) != 0;
 
     std::string_view path{raw_path};
-
-    if (path == "/dev/console") {
-        return 2000;
-    }
-    if (path == "/dev/deci_tty6") {
-        return 2001;
-    }
-    if (path == "/dev/urandom") {
-        return 2003;
-    }
-
     u32 handle = h->CreateHandle();
     auto* file = h->GetFile(handle);
 
@@ -167,9 +167,6 @@ int PS4_SYSV_ABI sceKernelClose(int d) {
     if (d < 3) { // d probably hold an error code
         return ORBIS_KERNEL_ERROR_EPERM;
     }
-    if (d == 2003) { // dev/urandom case
-        return ORBIS_OK;
-    }
     auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
     auto* file = h->GetFile(d);
     if (file == nullptr) {
@@ -337,13 +334,6 @@ s64 PS4_SYSV_ABI posix_lseek(int d, s64 offset, int whence) {
 }
 
 s64 PS4_SYSV_ABI sceKernelRead(int d, void* buf, size_t nbytes) {
-    if (d == 2003) // dev urandom case
-    {
-        auto rbuf = static_cast<char*>(buf);
-        for (size_t i = 0; i < nbytes; i++)
-            rbuf[i] = std::rand() & 0xFF;
-        return nbytes;
-    }
     auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
     auto* file = h->GetFile(d);
     if (file == nullptr) {
@@ -757,7 +747,6 @@ s32 PS4_SYSV_ABI sceKernelRename(const char* from, const char* to) {
 }
 
 void RegisterFileSystem(Core::Loader::SymbolsResolver* sym) {
-    std::srand(std::time(nullptr));
     LIB_FUNCTION("1G3lF1Gg1k8", "libkernel", 1, "libkernel", 1, 1, sceKernelOpen);
     LIB_FUNCTION("wuCroIGjt2g", "libScePosix", 1, "libkernel", 1, 1, posix_open);
     LIB_FUNCTION("wuCroIGjt2g", "libkernel", 1, "libkernel", 1, 1, open);

src/core/libraries/kernel/file_system.h

@@ -67,7 +67,8 @@ constexpr int ORBIS_KERNEL_O_DIRECTORY = 0x00020000;
 
 s64 PS4_SYSV_ABI sceKernelWrite(int d, const void* buf, size_t nbytes);
 s64 PS4_SYSV_ABI sceKernelRead(int d, void* buf, size_t nbytes);
-
+s64 PS4_SYSV_ABI sceKernelPread(int d, void* buf, size_t nbytes, s64 offset);
+s64 PS4_SYSV_ABI sceKernelPwrite(int d, void* buf, size_t nbytes, s64 offset);
 void RegisterFileSystem(Core::Loader::SymbolsResolver* sym);
 
 } // namespace Libraries::Kernel

src/core/libraries/kernel/kernel.cpp

@@ -28,6 +28,7 @@
 #include <Rpc.h>
 #endif
 #include <common/singleton.h>
+#include "aio.h"
 
 namespace Libraries::Kernel {
 
@@ -59,7 +60,7 @@ static void KernelServiceThread(std::stop_token stoken) {
         }
 
         io_context.run();
-        io_context.reset();
+        io_context.restart();
 
         asio_requests = 0;
     }
@@ -218,6 +219,7 @@ void RegisterKernel(Core::Loader::SymbolsResolver* sym) {
     Libraries::Kernel::RegisterEventQueue(sym);
     Libraries::Kernel::RegisterProcess(sym);
     Libraries::Kernel::RegisterException(sym);
+    Libraries::Kernel::RegisterAio(sym);
 
     LIB_OBJ("f7uOxY9mM1U", "libkernel", 1, "libkernel", 1, 1, &g_stack_chk_guard);
     LIB_FUNCTION("PfccT7qURYE", "libkernel", 1, "libkernel", 1, 1, kernel_ioctl);

src/core/libraries/kernel/threads/condvar.cpp

@@ -339,6 +339,8 @@ int PS4_SYSV_ABI posix_pthread_condattr_setpshared(PthreadCondAttrT* attr, int p
 void RegisterCond(Core::Loader::SymbolsResolver* sym) {
     // Posix
     LIB_FUNCTION("mKoTx03HRWA", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_condattr_init);
+    LIB_FUNCTION("dJcuQVn6-Iw", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_condattr_destroy);
     LIB_FUNCTION("0TyVk4MSLt0", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_cond_init);
     LIB_FUNCTION("2MOy+rUfuhQ", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_cond_signal);
     LIB_FUNCTION("RXXqi4CtF8w", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_cond_destroy);
@@ -347,8 +349,11 @@ void RegisterCond(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("mkx2fVhNMsg", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_cond_broadcast);
 
     // Posix-Kernel
+    LIB_FUNCTION("0TyVk4MSLt0", "libkernel", 1, "libkernel", 1, 1, posix_pthread_cond_init);
     LIB_FUNCTION("Op8TBGY5KHg", "libkernel", 1, "libkernel", 1, 1, posix_pthread_cond_wait);
     LIB_FUNCTION("mkx2fVhNMsg", "libkernel", 1, "libkernel", 1, 1, posix_pthread_cond_broadcast);
+    LIB_FUNCTION("mKoTx03HRWA", "libkernel", 1, "libkernel", 1, 1, posix_pthread_condattr_init);
+    LIB_FUNCTION("dJcuQVn6-Iw", "libkernel", 1, "libkernel", 1, 1, posix_pthread_condattr_destroy);
 
     // Orbis
     LIB_FUNCTION("2Tb92quprl0", "libkernel", 1, "libkernel", 1, 1, ORBIS(scePthreadCondInit));

src/core/libraries/kernel/threads/exception.cpp

@@ -153,6 +153,11 @@ int PS4_SYSV_ABI sceKernelDebugRaiseException() {
     return 0;
 }
 
+int PS4_SYSV_ABI sceKernelDebugRaiseExceptionOnReleaseMode() {
+    UNREACHABLE();
+    return 0;
+}
+
 void RegisterException(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("il03nluKfMk", "libkernel_unity", 1, "libkernel", 1, 1, sceKernelRaiseException);
     LIB_FUNCTION("WkwEd3N7w0Y", "libkernel_unity", 1, "libkernel", 1, 1,
@@ -160,6 +165,8 @@ void RegisterException(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("Qhv5ARAoOEc", "libkernel_unity", 1, "libkernel", 1, 1,
                  sceKernelRemoveExceptionHandler)
     LIB_FUNCTION("OMDRKKAZ8I4", "libkernel", 1, "libkernel", 1, 1, sceKernelDebugRaiseException);
+    LIB_FUNCTION("zE-wXIZjLoM", "libkernel", 1, "libkernel", 1, 1,
+                 sceKernelDebugRaiseExceptionOnReleaseMode);
 }
 
 } // namespace Libraries::Kernel

src/core/libraries/kernel/threads/mutex.cpp

@@ -438,8 +438,11 @@ void RegisterMutex(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("K-jXhbt2gn4", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_mutex_trylock);
 
     // Posix-Kernel
+    LIB_FUNCTION("ttHNfU+qDBU", "libkernel", 1, "libkernel", 1, 1, posix_pthread_mutex_init);
     LIB_FUNCTION("7H0iTOciTLo", "libkernel", 1, "libkernel", 1, 1, posix_pthread_mutex_lock);
     LIB_FUNCTION("2Z+PpY6CaJg", "libkernel", 1, "libkernel", 1, 1, posix_pthread_mutex_unlock);
+    LIB_FUNCTION("dQHWEsJtoE4", "libkernel", 1, "libkernel", 1, 1, posix_pthread_mutexattr_init);
+    LIB_FUNCTION("mDmgMOGVUqg", "libkernel", 1, "libkernel", 1, 1, posix_pthread_mutexattr_settype);
 
     // Orbis
     LIB_FUNCTION("cmo1RIYva9o", "libkernel", 1, "libkernel", 1, 1, ORBIS(scePthreadMutexInit));

src/core/libraries/kernel/threads/pthread.cpp

@@ -538,6 +538,7 @@ void RegisterThread(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("6XG4B33N09g", "libScePosix", 1, "libkernel", 1, 1, sched_yield);
 
     // Posix-Kernel
+    LIB_FUNCTION("Z4QosVuAsA0", "libkernel", 1, "libkernel", 1, 1, posix_pthread_once);
     LIB_FUNCTION("EotR8a3ASf4", "libkernel", 1, "libkernel", 1, 1, posix_pthread_self);
     LIB_FUNCTION("OxhIB8LB-PQ", "libkernel", 1, "libkernel", 1, 1, posix_pthread_create);
 

src/core/libraries/kernel/time.h

@@ -82,6 +82,7 @@ int PS4_SYSV_ABI sceKernelConvertLocaltimeToUtc(time_t param_1, int64_t param_2,
 
 int PS4_SYSV_ABI sceKernelConvertUtcToLocaltime(time_t time, time_t* local_time, OrbisTimesec* st,
                                                 u64* dst_sec);
+int PS4_SYSV_ABI sceKernelUsleep(u32 microseconds);
 
 void RegisterTime(Core::Loader::SymbolsResolver* sym);
 

src/core/libraries/libs.cpp

@@ -30,6 +30,7 @@
 #include "core/libraries/np_manager/np_manager.h"
 #include "core/libraries/np_score/np_score.h"
 #include "core/libraries/np_trophy/np_trophy.h"
+#include "core/libraries/np_web_api/np_web_api.h"
 #include "core/libraries/pad/pad.h"
 #include "core/libraries/playgo/playgo.h"
 #include "core/libraries/playgo/playgo_dialog.h"
@@ -81,6 +82,7 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) {
     Libraries::NpManager::RegisterlibSceNpManager(sym);
     Libraries::NpScore::RegisterlibSceNpScore(sym);
     Libraries::NpTrophy::RegisterlibSceNpTrophy(sym);
+    Libraries::NpWebApi::RegisterlibSceNpWebApi(sym);
     Libraries::ScreenShot::RegisterlibSceScreenShot(sym);
     Libraries::AppContent::RegisterlibSceAppContent(sym);
     Libraries::PngDec::RegisterlibScePngDec(sym);

src/core/libraries/network/netctl.cpp

@@ -93,7 +93,7 @@ int PS4_SYSV_ABI sceNetCtlUnregisterCallbackV6() {
 }
 
 int PS4_SYSV_ABI sceNetCtlCheckCallback() {
-    netctl.CheckCallback();
+    LOG_DEBUG(Lib_NetCtl, "(STUBBED) called");
     return ORBIS_OK;
 }
 
@@ -373,7 +373,7 @@ int PS4_SYSV_ABI Func_D8DCB6973537A3DC() {
 }
 
 int PS4_SYSV_ABI sceNetCtlCheckCallbackForNpToolkit() {
-    netctl.CheckNpToolkitCallback();
+    LOG_DEBUG(Lib_NetCtl, "(STUBBED) called");
     return ORBIS_OK;
 }
 

src/core/libraries/np_manager/np_manager.cpp

@@ -2509,7 +2509,7 @@ struct NpStateCallbackForNpToolkit {
 NpStateCallbackForNpToolkit NpStateCbForNp;
 
 int PS4_SYSV_ABI sceNpCheckCallbackForLib() {
-    Core::ExecuteGuest(NpStateCbForNp.func, 1, OrbisNpState::SignedOut, NpStateCbForNp.userdata);
+    LOG_DEBUG(Lib_NpManager, "(STUBBED) called");
     return ORBIS_OK;
 }
 

src/core/libraries/np_web_api/np_web_api.cpp

@@ -0,0 +1,692 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/logging/log.h"
+#include "core/libraries/error_codes.h"
+#include "core/libraries/libs.h"
+#include "core/libraries/np_web_api/np_web_api.h"
+
+namespace Libraries::NpWebApi {
+
+s32 PS4_SYSV_ABI sceNpWebApiCreateContext() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiCreatePushEventFilter() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiCreateServicePushEventFilter() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiDeletePushEventFilter() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiDeleteServicePushEventFilter() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiRegisterExtdPushEventCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiRegisterNotificationCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiRegisterPushEventCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiRegisterServicePushEventCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiUnregisterNotificationCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiUnregisterPushEventCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiUnregisterServicePushEventCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiAbortHandle() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiAbortRequest() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiAddHttpRequestHeader() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiAddMultipartPart() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiCheckTimeout() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiClearAllUnusedConnection() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiClearUnusedConnection() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiCreateContextA() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiCreateExtdPushEventFilter() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiCreateHandle() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiCreateMultipartRequest() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiCreateRequest() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiDeleteContext() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiDeleteExtdPushEventFilter() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiDeleteHandle() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiDeleteRequest() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiGetConnectionStats() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiGetErrorCode() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiGetHttpResponseHeaderValue() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiGetHttpResponseHeaderValueLength() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiGetHttpStatusCode() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiGetMemoryPoolStats() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiInitialize() {
+    LOG_ERROR(Lib_NpWebApi, "(DUMMY) called");
+    static s32 id = 0;
+    return ++id;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiInitializeForPresence() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiIntCreateCtxIndExtdPushEventFilter() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiIntCreateRequest() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiIntCreateServicePushEventFilter() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiIntInitialize() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiIntRegisterServicePushEventCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiIntRegisterServicePushEventCallbackA() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiReadData() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiRegisterExtdPushEventCallbackA() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiSendMultipartRequest() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiSendMultipartRequest2() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiSendRequest() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiSendRequest2() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiSetHandleTimeout() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiSetMaxConnection() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiSetMultipartContentType() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiSetRequestTimeout() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiTerminate() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiUnregisterExtdPushEventCallback() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiUtilityParseNpId() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceNpWebApiVshInitialize() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_064C4ED1EDBEB9E8() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_0783955D4E9563DA() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_1A6D77F3FD8323A8() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_1E0693A26FE0F954() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_24A9B5F1D77000CF() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_24AAA6F50E4C2361() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_24D8853D6B47FC79() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_279B3E9C7C4A9DC5() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_28461E29E9F8D697() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_3C29624704FAB9E0() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_3F027804ED2EC11E() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_4066C94E782997CD() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_47C85356815DBE90() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_4FCE8065437E3B87() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_536280BE3DABB521() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_57A0E1BC724219F3() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_5819749C040B6637() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_6198D0C825E86319() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_61F2B9E8AB093743() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_6BC388E6113F0D44() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_7500F0C4F8DC2D16() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_75A03814C7E9039F() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_789D6026C521416E() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_7DED63D06399EFFF() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_7E55A2DCC03D395A() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_7E6C8F9FB86967F4() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_7F04B7D4A7D41E80() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_8E167252DFA5C957() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_95D0046E504E3B09() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_97284BFDA4F18FDF() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_99E32C1F4737EAB4() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_9CFF661EA0BCBF83() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_9EB0E1F467AC3B29() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_A2318FE6FBABFAA3() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_BA07A2E1BF7B3971() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_BD0803EEE0CC29A0() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_BE6F4E5524BB135F() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_C0D490EB481EA4D0() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_C175D392CA6D084A() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_CD0136AF165D2F2F() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_D1C0ADB7B52FEAB5() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_E324765D18EE4D12() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_E789F980D907B653() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI Func_F9A32E8685627436() {
+    LOG_ERROR(Lib_NpWebApi, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterlibSceNpWebApi(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("x1Y7yiYSk7c", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateContext);
+    LIB_FUNCTION("y5Ta5JCzQHY", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreatePushEventFilter);
+    LIB_FUNCTION("sIFx734+xys", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateServicePushEventFilter);
+    LIB_FUNCTION("zE+R6Rcx3W0", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiDeletePushEventFilter);
+    LIB_FUNCTION("PfQ+f6ws764", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiDeleteServicePushEventFilter);
+    LIB_FUNCTION("vrM02A5Gy1M", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterExtdPushEventCallback);
+    LIB_FUNCTION("HVgWmGIOKdk", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterNotificationCallback);
+    LIB_FUNCTION("PfSTDCgNMgc", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterPushEventCallback);
+    LIB_FUNCTION("kJQJE0uKm5w", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterServicePushEventCallback);
+    LIB_FUNCTION("wjYEvo4xbcA", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiUnregisterNotificationCallback);
+    LIB_FUNCTION("qK4o2656W4w", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiUnregisterPushEventCallback);
+    LIB_FUNCTION("2edrkr0c-wg", "libSceNpWebApiCompat", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiUnregisterServicePushEventCallback);
+    LIB_FUNCTION("WKcm4PeyJww", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiAbortHandle);
+    LIB_FUNCTION("JzhYTP2fG18", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiAbortRequest);
+    LIB_FUNCTION("joRjtRXTFoc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiAddHttpRequestHeader);
+    LIB_FUNCTION("19KgfJXgM+U", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiAddMultipartPart);
+    LIB_FUNCTION("gVNNyxf-1Sg", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCheckTimeout);
+    LIB_FUNCTION("KQIkDGf80PQ", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiClearAllUnusedConnection);
+    LIB_FUNCTION("f-pgaNSd1zc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiClearUnusedConnection);
+    LIB_FUNCTION("x1Y7yiYSk7c", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateContext);
+    LIB_FUNCTION("zk6c65xoyO0", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateContextA);
+    LIB_FUNCTION("M2BUB+DNEGE", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateExtdPushEventFilter);
+    LIB_FUNCTION("79M-JqvvGo0", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateHandle);
+    LIB_FUNCTION("KBxgeNpoRIQ", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateMultipartRequest);
+    LIB_FUNCTION("y5Ta5JCzQHY", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreatePushEventFilter);
+    LIB_FUNCTION("rdgs5Z1MyFw", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateRequest);
+    LIB_FUNCTION("sIFx734+xys", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiCreateServicePushEventFilter);
+    LIB_FUNCTION("XUjdsSTTZ3U", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiDeleteContext);
+    LIB_FUNCTION("pfaJtb7SQ80", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiDeleteExtdPushEventFilter);
+    LIB_FUNCTION("5Mn7TYwpl30", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiDeleteHandle);
+    LIB_FUNCTION("zE+R6Rcx3W0", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiDeletePushEventFilter);
+    LIB_FUNCTION("noQgleu+KLE", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiDeleteRequest);
+    LIB_FUNCTION("PfQ+f6ws764", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiDeleteServicePushEventFilter);
+    LIB_FUNCTION("UJ8H+7kVQUE", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiGetConnectionStats);
+    LIB_FUNCTION("2qSZ0DgwTsc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiGetErrorCode);
+    LIB_FUNCTION("VwJ5L0Higg0", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiGetHttpResponseHeaderValue);
+    LIB_FUNCTION("743ZzEBzlV8", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiGetHttpResponseHeaderValueLength);
+    LIB_FUNCTION("k210oKgP80Y", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiGetHttpStatusCode);
+    LIB_FUNCTION("3OnubUs02UM", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiGetMemoryPoolStats);
+    LIB_FUNCTION("G3AnLNdRBjE", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, sceNpWebApiInitialize);
+    LIB_FUNCTION("FkuwsD64zoQ", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiInitializeForPresence);
+    LIB_FUNCTION("c1pKoztonB8", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiIntCreateCtxIndExtdPushEventFilter);
+    LIB_FUNCTION("N2Jbx4tIaQ4", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiIntCreateRequest);
+    LIB_FUNCTION("TZSep4xB4EY", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiIntCreateServicePushEventFilter);
+    LIB_FUNCTION("8Vjplhyyc44", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiIntInitialize);
+    LIB_FUNCTION("VjVukb2EWPc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiIntRegisterServicePushEventCallback);
+    LIB_FUNCTION("sfq23ZVHVEw", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiIntRegisterServicePushEventCallbackA);
+    LIB_FUNCTION("CQtPRSF6Ds8", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, sceNpWebApiReadData);
+    LIB_FUNCTION("vrM02A5Gy1M", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterExtdPushEventCallback);
+    LIB_FUNCTION("jhXKGQJ4egI", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterExtdPushEventCallbackA);
+    LIB_FUNCTION("HVgWmGIOKdk", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterNotificationCallback);
+    LIB_FUNCTION("PfSTDCgNMgc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterPushEventCallback);
+    LIB_FUNCTION("kJQJE0uKm5w", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiRegisterServicePushEventCallback);
+    LIB_FUNCTION("KCItz6QkeGs", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiSendMultipartRequest);
+    LIB_FUNCTION("DsPOTEvSe7M", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiSendMultipartRequest2);
+    LIB_FUNCTION("kVbL4hL3K7w", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiSendRequest);
+    LIB_FUNCTION("KjNeZ-29ysQ", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiSendRequest2);
+    LIB_FUNCTION("6g6q-g1i4XU", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiSetHandleTimeout);
+    LIB_FUNCTION("gRiilVCvfAI", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiSetMaxConnection);
+    LIB_FUNCTION("i0dr6grIZyc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiSetMultipartContentType);
+    LIB_FUNCTION("qWcbJkBj1Lg", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiSetRequestTimeout);
+    LIB_FUNCTION("asz3TtIqGF8", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, sceNpWebApiTerminate);
+    LIB_FUNCTION("PqCY25FMzPs", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiUnregisterExtdPushEventCallback);
+    LIB_FUNCTION("wjYEvo4xbcA", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiUnregisterNotificationCallback);
+    LIB_FUNCTION("qK4o2656W4w", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiUnregisterPushEventCallback);
+    LIB_FUNCTION("2edrkr0c-wg", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiUnregisterServicePushEventCallback);
+    LIB_FUNCTION("or0e885BlXo", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiUtilityParseNpId);
+    LIB_FUNCTION("uRsskUhAfnM", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1,
+                 sceNpWebApiVshInitialize);
+    LIB_FUNCTION("BkxO0e2+ueg", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_064C4ED1EDBEB9E8);
+    LIB_FUNCTION("B4OVXU6VY9o", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_0783955D4E9563DA);
+    LIB_FUNCTION("Gm138-2DI6g", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_1A6D77F3FD8323A8);
+    LIB_FUNCTION("HgaTom-g+VQ", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_1E0693A26FE0F954);
+    LIB_FUNCTION("JKm18ddwAM8", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_24A9B5F1D77000CF);
+    LIB_FUNCTION("JKqm9Q5MI2E", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_24AAA6F50E4C2361);
+    LIB_FUNCTION("JNiFPWtH-Hk", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_24D8853D6B47FC79);
+    LIB_FUNCTION("J5s+nHxKncU", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_279B3E9C7C4A9DC5);
+    LIB_FUNCTION("KEYeKen41pc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_28461E29E9F8D697);
+    LIB_FUNCTION("PCliRwT6ueA", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_3C29624704FAB9E0);
+    LIB_FUNCTION("PwJ4BO0uwR4", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_3F027804ED2EC11E);
+    LIB_FUNCTION("QGbJTngpl80", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_4066C94E782997CD);
+    LIB_FUNCTION("R8hTVoFdvpA", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_47C85356815DBE90);
+    LIB_FUNCTION("T86AZUN+O4c", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_4FCE8065437E3B87);
+    LIB_FUNCTION("U2KAvj2rtSE", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_536280BE3DABB521);
+    LIB_FUNCTION("V6DhvHJCGfM", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_57A0E1BC724219F3);
+    LIB_FUNCTION("WBl0nAQLZjc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_5819749C040B6637);
+    LIB_FUNCTION("YZjQyCXoYxk", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_6198D0C825E86319);
+    LIB_FUNCTION("YfK56KsJN0M", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_61F2B9E8AB093743);
+    LIB_FUNCTION("a8OI5hE-DUQ", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_6BC388E6113F0D44);
+    LIB_FUNCTION("dQDwxPjcLRY", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_7500F0C4F8DC2D16);
+    LIB_FUNCTION("daA4FMfpA58", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_75A03814C7E9039F);
+    LIB_FUNCTION("eJ1gJsUhQW4", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_789D6026C521416E);
+    LIB_FUNCTION("fe1j0GOZ7-8", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_7DED63D06399EFFF);
+    LIB_FUNCTION("flWi3MA9OVo", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_7E55A2DCC03D395A);
+    LIB_FUNCTION("fmyPn7hpZ-Q", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_7E6C8F9FB86967F4);
+    LIB_FUNCTION("fwS31KfUHoA", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_7F04B7D4A7D41E80);
+    LIB_FUNCTION("jhZyUt+lyVc", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_8E167252DFA5C957);
+    LIB_FUNCTION("ldAEblBOOwk", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_95D0046E504E3B09);
+    LIB_FUNCTION("lyhL-aTxj98", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_97284BFDA4F18FDF);
+    LIB_FUNCTION("meMsH0c36rQ", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_99E32C1F4737EAB4);
+    LIB_FUNCTION("nP9mHqC8v4M", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_9CFF661EA0BCBF83);
+    LIB_FUNCTION("nrDh9GesOyk", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_9EB0E1F467AC3B29);
+    LIB_FUNCTION("ojGP5vur+qM", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_A2318FE6FBABFAA3);
+    LIB_FUNCTION("ugei4b97OXE", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_BA07A2E1BF7B3971);
+    LIB_FUNCTION("vQgD7uDMKaA", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_BD0803EEE0CC29A0);
+    LIB_FUNCTION("vm9OVSS7E18", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_BE6F4E5524BB135F);
+    LIB_FUNCTION("wNSQ60gepNA", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_C0D490EB481EA4D0);
+    LIB_FUNCTION("wXXTksptCEo", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_C175D392CA6D084A);
+    LIB_FUNCTION("zQE2rxZdLy8", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_CD0136AF165D2F2F);
+    LIB_FUNCTION("0cCtt7Uv6rU", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_D1C0ADB7B52FEAB5);
+    LIB_FUNCTION("4yR2XRjuTRI", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_E324765D18EE4D12);
+    LIB_FUNCTION("54n5gNkHtlM", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_E789F980D907B653);
+    LIB_FUNCTION("+aMuhoVidDY", "libSceNpWebApi", 1, "libSceNpWebApi", 1, 1, Func_F9A32E8685627436);
+};
+
+} // namespace Libraries::NpWebApi

src/core/libraries/np_web_api/np_web_api.h

@@ -0,0 +1,116 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/types.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
+
+namespace Libraries::NpWebApi {
+
+s32 PS4_SYSV_ABI sceNpWebApiCreateContext();
+s32 PS4_SYSV_ABI sceNpWebApiCreatePushEventFilter();
+s32 PS4_SYSV_ABI sceNpWebApiCreateServicePushEventFilter();
+s32 PS4_SYSV_ABI sceNpWebApiDeletePushEventFilter();
+s32 PS4_SYSV_ABI sceNpWebApiDeleteServicePushEventFilter();
+s32 PS4_SYSV_ABI sceNpWebApiRegisterExtdPushEventCallback();
+s32 PS4_SYSV_ABI sceNpWebApiRegisterNotificationCallback();
+s32 PS4_SYSV_ABI sceNpWebApiRegisterPushEventCallback();
+s32 PS4_SYSV_ABI sceNpWebApiRegisterServicePushEventCallback();
+s32 PS4_SYSV_ABI sceNpWebApiUnregisterNotificationCallback();
+s32 PS4_SYSV_ABI sceNpWebApiUnregisterPushEventCallback();
+s32 PS4_SYSV_ABI sceNpWebApiUnregisterServicePushEventCallback();
+s32 PS4_SYSV_ABI sceNpWebApiAbortHandle();
+s32 PS4_SYSV_ABI sceNpWebApiAbortRequest();
+s32 PS4_SYSV_ABI sceNpWebApiAddHttpRequestHeader();
+s32 PS4_SYSV_ABI sceNpWebApiAddMultipartPart();
+s32 PS4_SYSV_ABI sceNpWebApiCheckTimeout();
+s32 PS4_SYSV_ABI sceNpWebApiClearAllUnusedConnection();
+s32 PS4_SYSV_ABI sceNpWebApiClearUnusedConnection();
+s32 PS4_SYSV_ABI sceNpWebApiCreateContextA();
+s32 PS4_SYSV_ABI sceNpWebApiCreateExtdPushEventFilter();
+s32 PS4_SYSV_ABI sceNpWebApiCreateHandle();
+s32 PS4_SYSV_ABI sceNpWebApiCreateMultipartRequest();
+s32 PS4_SYSV_ABI sceNpWebApiCreateRequest();
+s32 PS4_SYSV_ABI sceNpWebApiDeleteContext();
+s32 PS4_SYSV_ABI sceNpWebApiDeleteExtdPushEventFilter();
+s32 PS4_SYSV_ABI sceNpWebApiDeleteHandle();
+s32 PS4_SYSV_ABI sceNpWebApiDeleteRequest();
+s32 PS4_SYSV_ABI sceNpWebApiGetConnectionStats();
+s32 PS4_SYSV_ABI sceNpWebApiGetErrorCode();
+s32 PS4_SYSV_ABI sceNpWebApiGetHttpResponseHeaderValue();
+s32 PS4_SYSV_ABI sceNpWebApiGetHttpResponseHeaderValueLength();
+s32 PS4_SYSV_ABI sceNpWebApiGetHttpStatusCode();
+s32 PS4_SYSV_ABI sceNpWebApiGetMemoryPoolStats();
+s32 PS4_SYSV_ABI sceNpWebApiInitialize();
+s32 PS4_SYSV_ABI sceNpWebApiInitializeForPresence();
+s32 PS4_SYSV_ABI sceNpWebApiIntCreateCtxIndExtdPushEventFilter();
+s32 PS4_SYSV_ABI sceNpWebApiIntCreateRequest();
+s32 PS4_SYSV_ABI sceNpWebApiIntCreateServicePushEventFilter();
+s32 PS4_SYSV_ABI sceNpWebApiIntInitialize();
+s32 PS4_SYSV_ABI sceNpWebApiIntRegisterServicePushEventCallback();
+s32 PS4_SYSV_ABI sceNpWebApiIntRegisterServicePushEventCallbackA();
+s32 PS4_SYSV_ABI sceNpWebApiReadData();
+s32 PS4_SYSV_ABI sceNpWebApiRegisterExtdPushEventCallbackA();
+s32 PS4_SYSV_ABI sceNpWebApiSendMultipartRequest();
+s32 PS4_SYSV_ABI sceNpWebApiSendMultipartRequest2();
+s32 PS4_SYSV_ABI sceNpWebApiSendRequest();
+s32 PS4_SYSV_ABI sceNpWebApiSendRequest2();
+s32 PS4_SYSV_ABI sceNpWebApiSetHandleTimeout();
+s32 PS4_SYSV_ABI sceNpWebApiSetMaxConnection();
+s32 PS4_SYSV_ABI sceNpWebApiSetMultipartContentType();
+s32 PS4_SYSV_ABI sceNpWebApiSetRequestTimeout();
+s32 PS4_SYSV_ABI sceNpWebApiTerminate();
+s32 PS4_SYSV_ABI sceNpWebApiUnregisterExtdPushEventCallback();
+s32 PS4_SYSV_ABI sceNpWebApiUtilityParseNpId();
+s32 PS4_SYSV_ABI sceNpWebApiVshInitialize();
+s32 PS4_SYSV_ABI Func_064C4ED1EDBEB9E8();
+s32 PS4_SYSV_ABI Func_0783955D4E9563DA();
+s32 PS4_SYSV_ABI Func_1A6D77F3FD8323A8();
+s32 PS4_SYSV_ABI Func_1E0693A26FE0F954();
+s32 PS4_SYSV_ABI Func_24A9B5F1D77000CF();
+s32 PS4_SYSV_ABI Func_24AAA6F50E4C2361();
+s32 PS4_SYSV_ABI Func_24D8853D6B47FC79();
+s32 PS4_SYSV_ABI Func_279B3E9C7C4A9DC5();
+s32 PS4_SYSV_ABI Func_28461E29E9F8D697();
+s32 PS4_SYSV_ABI Func_3C29624704FAB9E0();
+s32 PS4_SYSV_ABI Func_3F027804ED2EC11E();
+s32 PS4_SYSV_ABI Func_4066C94E782997CD();
+s32 PS4_SYSV_ABI Func_47C85356815DBE90();
+s32 PS4_SYSV_ABI Func_4FCE8065437E3B87();
+s32 PS4_SYSV_ABI Func_536280BE3DABB521();
+s32 PS4_SYSV_ABI Func_57A0E1BC724219F3();
+s32 PS4_SYSV_ABI Func_5819749C040B6637();
+s32 PS4_SYSV_ABI Func_6198D0C825E86319();
+s32 PS4_SYSV_ABI Func_61F2B9E8AB093743();
+s32 PS4_SYSV_ABI Func_6BC388E6113F0D44();
+s32 PS4_SYSV_ABI Func_7500F0C4F8DC2D16();
+s32 PS4_SYSV_ABI Func_75A03814C7E9039F();
+s32 PS4_SYSV_ABI Func_789D6026C521416E();
+s32 PS4_SYSV_ABI Func_7DED63D06399EFFF();
+s32 PS4_SYSV_ABI Func_7E55A2DCC03D395A();
+s32 PS4_SYSV_ABI Func_7E6C8F9FB86967F4();
+s32 PS4_SYSV_ABI Func_7F04B7D4A7D41E80();
+s32 PS4_SYSV_ABI Func_8E167252DFA5C957();
+s32 PS4_SYSV_ABI Func_95D0046E504E3B09();
+s32 PS4_SYSV_ABI Func_97284BFDA4F18FDF();
+s32 PS4_SYSV_ABI Func_99E32C1F4737EAB4();
+s32 PS4_SYSV_ABI Func_9CFF661EA0BCBF83();
+s32 PS4_SYSV_ABI Func_9EB0E1F467AC3B29();
+s32 PS4_SYSV_ABI Func_A2318FE6FBABFAA3();
+s32 PS4_SYSV_ABI Func_BA07A2E1BF7B3971();
+s32 PS4_SYSV_ABI Func_BD0803EEE0CC29A0();
+s32 PS4_SYSV_ABI Func_BE6F4E5524BB135F();
+s32 PS4_SYSV_ABI Func_C0D490EB481EA4D0();
+s32 PS4_SYSV_ABI Func_C175D392CA6D084A();
+s32 PS4_SYSV_ABI Func_CD0136AF165D2F2F();
+s32 PS4_SYSV_ABI Func_D1C0ADB7B52FEAB5();
+s32 PS4_SYSV_ABI Func_E324765D18EE4D12();
+s32 PS4_SYSV_ABI Func_E789F980D907B653();
+s32 PS4_SYSV_ABI Func_F9A32E8685627436();
+
+void RegisterlibSceNpWebApi(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::NpWebApi

src/core/libraries/pad/pad.cpp

@@ -11,6 +11,8 @@
 
 namespace Libraries::Pad {
 
+using Input::GameController;
+
 int PS4_SYSV_ABI scePadClose(s32 handle) {
     LOG_ERROR(Lib_Pad, "(STUBBED) called");
     return ORBIS_OK;
@@ -93,8 +95,8 @@ int PS4_SYSV_ABI scePadGetControllerInformation(s32 handle, OrbisPadControllerIn
         pInfo->touchPadInfo.pixelDensity = 1;
         pInfo->touchPadInfo.resolution.x = 1920;
         pInfo->touchPadInfo.resolution.y = 950;
-        pInfo->stickInfo.deadZoneLeft = 2;
-        pInfo->stickInfo.deadZoneRight = 2;
+        pInfo->stickInfo.deadZoneLeft = Config::leftDeadZone();
+        pInfo->stickInfo.deadZoneRight = Config::rightDeadZone();
         pInfo->connectionType = ORBIS_PAD_PORT_TYPE_STANDARD;
         pInfo->connectedCount = 1;
         pInfo->connected = false;
@@ -104,8 +106,8 @@ int PS4_SYSV_ABI scePadGetControllerInformation(s32 handle, OrbisPadControllerIn
     pInfo->touchPadInfo.pixelDensity = 1;
     pInfo->touchPadInfo.resolution.x = 1920;
     pInfo->touchPadInfo.resolution.y = 950;
-    pInfo->stickInfo.deadZoneLeft = 2;
-    pInfo->stickInfo.deadZoneRight = 2;
+    pInfo->stickInfo.deadZoneLeft = Config::leftDeadZone();
+    pInfo->stickInfo.deadZoneRight = Config::rightDeadZone();
     pInfo->connectionType = ORBIS_PAD_PORT_TYPE_STANDARD;
     pInfo->connectedCount = 1;
     pInfo->connected = true;
@@ -290,7 +292,8 @@ int PS4_SYSV_ABI scePadRead(s32 handle, OrbisPadData* pData, s32 num) {
     int connected_count = 0;
     bool connected = false;
     Input::State states[64];
-    auto* controller = Common::Singleton<Input::GameController>::Instance();
+    auto* controller = Common::Singleton<GameController>::Instance();
+    const auto* engine = controller->GetEngine();
     int ret_num = controller->ReadStates(states, num, &connected, &connected_count);
 
     if (!connected) {
@@ -311,9 +314,14 @@ int PS4_SYSV_ABI scePadRead(s32 handle, OrbisPadData* pData, s32 num) {
         pData[i].angularVelocity.x = states[i].angularVelocity.x;
         pData[i].angularVelocity.y = states[i].angularVelocity.y;
         pData[i].angularVelocity.z = states[i].angularVelocity.z;
-        Input::GameController::CalculateOrientation(pData[i].acceleration, pData[i].angularVelocity,
-                                                    1.0f / controller->accel_poll_rate,
-                                                    pData[i].orientation);
+        if (engine) {
+            const auto accel_poll_rate = engine->GetAccelPollRate();
+            if (accel_poll_rate != 0.0f) {
+                GameController::CalculateOrientation(pData[i].acceleration,
+                                                     pData[i].angularVelocity,
+                                                     1.0f / accel_poll_rate, pData[i].orientation);
+            }
+        }
         pData[i].touchData.touchNum =
             (states[i].touchpad[0].state ? 1 : 0) + (states[i].touchpad[1].state ? 1 : 0);
         pData[i].touchData.touch[0].x = states[i].touchpad[0].x;
@@ -356,7 +364,8 @@ int PS4_SYSV_ABI scePadReadState(s32 handle, OrbisPadData* pData) {
     if (handle == ORBIS_PAD_ERROR_DEVICE_NO_HANDLE) {
         return ORBIS_PAD_ERROR_INVALID_HANDLE;
     }
-    auto* controller = Common::Singleton<Input::GameController>::Instance();
+    auto* controller = Common::Singleton<GameController>::Instance();
+    const auto* engine = controller->GetEngine();
     int connectedCount = 0;
     bool isConnected = false;
     Input::State state;
@@ -374,9 +383,13 @@ int PS4_SYSV_ABI scePadReadState(s32 handle, OrbisPadData* pData) {
     pData->angularVelocity.x = state.angularVelocity.x;
     pData->angularVelocity.y = state.angularVelocity.y;
     pData->angularVelocity.z = state.angularVelocity.z;
-    Input::GameController::CalculateOrientation(pData->acceleration, pData->angularVelocity,
-                                                1.0f / controller->accel_poll_rate,
-                                                pData->orientation);
+    if (engine) {
+        const auto accel_poll_rate = engine->GetAccelPollRate();
+        if (accel_poll_rate != 0.0f) {
+            GameController::CalculateOrientation(pData->acceleration, pData->angularVelocity,
+                                                 1.0f / accel_poll_rate, pData->orientation);
+        }
+    }
     pData->touchData.touchNum =
         (state.touchpad[0].state ? 1 : 0) + (state.touchpad[1].state ? 1 : 0);
     pData->touchData.touch[0].x = state.touchpad[0].x;
@@ -468,7 +481,7 @@ int PS4_SYSV_ABI scePadSetLightBar(s32 handle, const OrbisPadLightBarParam* pPar
             return ORBIS_PAD_ERROR_INVALID_LIGHTBAR_SETTING;
         }
 
-        auto* controller = Common::Singleton<Input::GameController>::Instance();
+        auto* controller = Common::Singleton<GameController>::Instance();
         controller->SetLightBarRGB(pParam->r, pParam->g, pParam->b);
         return ORBIS_OK;
     }
@@ -536,7 +549,7 @@ int PS4_SYSV_ABI scePadSetVibration(s32 handle, const OrbisPadVibrationParam* pP
     if (pParam != nullptr) {
         LOG_DEBUG(Lib_Pad, "scePadSetVibration called handle = {} data = {} , {}", handle,
                   pParam->smallMotor, pParam->largeMotor);
-        auto* controller = Common::Singleton<Input::GameController>::Instance();
+        auto* controller = Common::Singleton<GameController>::Instance();
         controller->SetVibration(pParam->smallMotor, pParam->largeMotor);
         return ORBIS_OK;
     }

src/core/libraries/videoout/driver.cpp

@@ -1,8 +1,6 @@
 // SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <imgui.h>
-
 #include "common/assert.h"
 #include "common/config.h"
 #include "common/debug.h"
@@ -11,6 +9,7 @@
 #include "core/libraries/kernel/time.h"
 #include "core/libraries/videoout/driver.h"
 #include "core/libraries/videoout/videoout_error.h"
+#include "imgui/renderer/imgui_core.h"
 #include "video_core/renderer_vulkan/vk_presenter.h"
 
 extern std::unique_ptr<Vulkan::Presenter> presenter;
@@ -207,6 +206,13 @@ void VideoOutDriver::DrawBlankFrame() {
     presenter->Present(empty_frame);
 }
 
+void VideoOutDriver::DrawLastFrame() {
+    const auto frame = presenter->PrepareLastFrame();
+    if (frame != nullptr) {
+        presenter->Present(frame, true);
+    }
+}
+
 bool VideoOutDriver::SubmitFlip(VideoOutPort* port, s32 index, s64 flip_arg,
                                 bool is_eop /*= false*/) {
     {
@@ -278,17 +284,26 @@ void VideoOutDriver::PresentThread(std::stop_token token) {
         return {};
     };
 
-    auto delay = std::chrono::microseconds{0};
     while (!token.stop_requested()) {
         timer.Start();
 
+        if (DebugState.IsGuestThreadsPaused()) {
+            DrawLastFrame();
+            timer.End();
+            continue;
+        }
+
         // Check if it's time to take a request.
         auto& vblank_status = main_port.vblank_status;
         if (vblank_status.count % (main_port.flip_rate + 1) == 0) {
             const auto request = receive_request();
             if (!request) {
-                if (!main_port.is_open || DebugState.IsGuestThreadsPaused()) {
-                    DrawBlankFrame();
+                if (timer.GetTotalWait().count() < 0) { // Dont draw too fast
+                    if (!main_port.is_open) {
+                        DrawBlankFrame();
+                    } else if (ImGui::Core::MustKeepDrawing()) {
+                        DrawLastFrame();
+                    }
                 }
             } else {
                 Flip(request);

src/core/libraries/videoout/driver.h

@@ -102,7 +102,8 @@ private:
     };
 
     void Flip(const Request& req);
-    void DrawBlankFrame(); // Used when there is no flip request to keep ImGui up to date
+    void DrawBlankFrame(); // Video port out not open
+    void DrawLastFrame();  // Used when there is no flip request
     void SubmitFlipInternal(VideoOutPort* port, s32 index, s64 flip_arg, bool is_eop = false);
     void PresentThread(std::stop_token token);
 

src/core/linker.cpp

@@ -52,7 +52,7 @@ Linker::Linker() : memory{Memory::Instance()} {}
 
 Linker::~Linker() = default;
 
-void Linker::Execute() {
+void Linker::Execute(const std::vector<std::string> args) {
     if (Config::debugDump()) {
         DebugDump();
     }
@@ -101,7 +101,7 @@ void Linker::Execute() {
 
     memory->SetupMemoryRegions(fmem_size, use_extended_mem1, use_extended_mem2);
 
-    main_thread.Run([this, module](std::stop_token) {
+    main_thread.Run([this, module, args](std::stop_token) {
         Common::SetCurrentThreadName("GAME_MainThread");
         LoadSharedLibraries();
 
@@ -109,6 +109,12 @@ void Linker::Execute() {
         EntryParams params{};
         params.argc = 1;
         params.argv[0] = "eboot.bin";
+        if (!args.empty()) {
+            params.argc = args.size() + 1;
+            for (int i = 0; i < args.size() && i < 32; i++) {
+                params.argv[i + 1] = args[i].c_str();
+            }
+        }
         params.entry_addr = module->GetEntryAddress();
         RunMainEntry(&params);
     });

src/core/linker.h

@@ -49,7 +49,7 @@ class Linker;
 struct EntryParams {
     int argc;
     u32 padding;
-    const char* argv[3];
+    const char* argv[33];
     VAddr entry_addr;
 };
 
@@ -143,7 +143,7 @@ public:
     void Relocate(Module* module);
     bool Resolve(const std::string& name, Loader::SymbolType type, Module* module,
                  Loader::SymbolRecord* return_info);
-    void Execute();
+    void Execute(const std::vector<std::string> args = {});
     void DebugDump();
 
 private:

src/emulator.cpp

@@ -66,9 +66,10 @@ Emulator::Emulator() {
     LOG_INFO(Config, "Vulkan vkValidation: {}", Config::vkValidationEnabled());
     LOG_INFO(Config, "Vulkan vkValidationSync: {}", Config::vkValidationSyncEnabled());
     LOG_INFO(Config, "Vulkan vkValidationGpu: {}", Config::vkValidationGpuEnabled());
-    LOG_INFO(Config, "Vulkan rdocEnable: {}", Config::isRdocEnabled());
-    LOG_INFO(Config, "Vulkan rdocMarkersEnable: {}", Config::vkMarkersEnabled());
     LOG_INFO(Config, "Vulkan crashDiagnostics: {}", Config::vkCrashDiagnosticEnabled());
+    LOG_INFO(Config, "Vulkan hostMarkers: {}", Config::vkHostMarkersEnabled());
+    LOG_INFO(Config, "Vulkan guestMarkers: {}", Config::vkGuestMarkersEnabled());
+    LOG_INFO(Config, "Vulkan rdocEnable: {}", Config::isRdocEnabled());
 
     // Create stdin/stdout/stderr
     Common::Singleton<FileSys::HandleTable>::Instance()->CreateStdHandles();
@@ -98,7 +99,7 @@ Emulator::~Emulator() {
     Config::saveMainWindow(config_dir / "config.toml");
 }
 
-void Emulator::Run(const std::filesystem::path& file) {
+void Emulator::Run(const std::filesystem::path& file, const std::vector<std::string> args) {
     // Applications expect to be run from /app0 so mount the file's parent path as app0.
     auto* mnt = Common::Singleton<Core::FileSys::MntPoints>::Instance();
     const auto game_folder = file.parent_path();
@@ -151,6 +152,15 @@ void Emulator::Run(const std::filesystem::path& file) {
         if (const auto raw_attributes = param_sfo->GetInteger("ATTRIBUTE")) {
             psf_attributes.raw = *raw_attributes;
         }
+        if (!args.empty()) {
+            int argc = std::min<int>(args.size(), 32);
+            for (int i = 0; i < argc; i++) {
+                LOG_INFO(Loader, "Game argument {}: {}", i, args[i]);
+            }
+            if (args.size() > 32) {
+                LOG_ERROR(Loader, "Too many game arguments, only passing the first 32");
+            }
+        }
     }
 
     const auto pic1_path = mnt->GetHostPath("/app0/sce_sys/pic1.png");
@@ -238,7 +248,7 @@ void Emulator::Run(const std::filesystem::path& file) {
     }
 #endif
 
-    linker->Execute();
+    linker->Execute(args);
 
     window->InitTimers();
     while (window->IsOpen()) {

src/emulator.h

@@ -25,7 +25,7 @@ public:
     Emulator();
     ~Emulator();
 
-    void Run(const std::filesystem::path& file);
+    void Run(const std::filesystem::path& file, const std::vector<std::string> args = {});
     void UpdatePlayTime(const std::string& serial);
 
 private:

src/imgui/imgui_config.h

@@ -30,6 +30,12 @@ extern void assert_fail_debug_msg(const char* msg);
 #define IM_VEC4_CLASS_EXTRA                                                                        \
     constexpr ImVec4(float _v) : x(_v), y(_v), z(_v), w(_v) {}
 
+namespace ImGui {
+struct Texture;
+}
+#define ImTextureID ImTextureID
+using ImTextureID = ::ImGui::Texture*;
+
 #ifdef IMGUI_USE_WCHAR32
 #error "This project uses 16 bits wchar standard like Orbis"
 #endif

src/imgui/renderer/imgui_core.cpp

@@ -6,6 +6,7 @@
 
 #include "common/config.h"
 #include "common/path_util.h"
+#include "core/debug_state.h"
 #include "core/devtools/layer.h"
 #include "imgui/imgui_layer.h"
 #include "imgui_core.h"
@@ -167,7 +168,7 @@ bool ProcessEvent(SDL_Event* event) {
     }
 }
 
-void NewFrame() {
+ImGuiID NewFrame(bool is_reusing_frame) {
     {
         std::scoped_lock lock{change_layers_mutex};
         while (!change_layers.empty()) {
@@ -182,24 +183,32 @@ void NewFrame() {
         }
     }
 
-    Sdl::NewFrame();
+    Sdl::NewFrame(is_reusing_frame);
     ImGui::NewFrame();
 
-    DockSpaceOverViewport(0, GetMainViewport(), ImGuiDockNodeFlags_PassthruCentralNode);
+    ImGuiWindowFlags flags =
+        ImGuiDockNodeFlags_PassthruCentralNode | ImGuiDockNodeFlags_AutoHideTabBar;
+    if (!DebugState.IsShowingDebugMenuBar()) {
+        flags |= ImGuiDockNodeFlags_NoTabBar;
+    }
+    ImGuiID dockId = DockSpaceOverViewport(0, GetMainViewport(), flags);
 
     for (auto* layer : layers) {
         layer->Draw();
     }
+
+    return dockId;
 }
 
-void Render(const vk::CommandBuffer& cmdbuf, ::Vulkan::Frame* frame) {
+void Render(const vk::CommandBuffer& cmdbuf, const vk::ImageView& image_view,
+            const vk::Extent2D& extent) {
     ImGui::Render();
     ImDrawData* draw_data = GetDrawData();
     if (draw_data->CmdListsCount == 0) {
         return;
     }
 
-    if (Config::vkMarkersEnabled()) {
+    if (Config::vkHostMarkersEnabled()) {
         cmdbuf.beginDebugUtilsLabelEXT(vk::DebugUtilsLabelEXT{
             .pLabelName = "ImGui Render",
         });
@@ -207,16 +216,16 @@ void Render(const vk::CommandBuffer& cmdbuf, ::Vulkan::Frame* frame) {
 
     vk::RenderingAttachmentInfo color_attachments[1]{
         {
-            .imageView = frame->image_view,
+            .imageView = image_view,
             .imageLayout = vk::ImageLayout::eColorAttachmentOptimal,
-            .loadOp = vk::AttachmentLoadOp::eLoad,
+            .loadOp = vk::AttachmentLoadOp::eClear,
             .storeOp = vk::AttachmentStoreOp::eStore,
         },
     };
     vk::RenderingInfo render_info{};
     render_info.renderArea = vk::Rect2D{
         .offset = {0, 0},
-        .extent = {frame->width, frame->height},
+        .extent = extent,
     };
     render_info.layerCount = 1;
     render_info.colorAttachmentCount = 1;
@@ -224,11 +233,15 @@ void Render(const vk::CommandBuffer& cmdbuf, ::Vulkan::Frame* frame) {
     cmdbuf.beginRendering(render_info);
     Vulkan::RenderDrawData(*draw_data, cmdbuf);
     cmdbuf.endRendering();
-    if (Config::vkMarkersEnabled()) {
+    if (Config::vkHostMarkersEnabled()) {
         cmdbuf.endDebugUtilsLabelEXT();
     }
 }
 
+bool MustKeepDrawing() {
+    return layers.size() > 1 || DebugState.IsShowingDebugMenuBar();
+}
+
 } // namespace Core
 
 void Layer::AddLayer(Layer* layer) {

src/imgui/renderer/imgui_core.h

@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <imgui.h>
+
 #include "video_core/renderer_vulkan/vk_instance.h"
 #include "vulkan/vulkan_handles.hpp"
 
@@ -24,8 +26,11 @@ void Shutdown(const vk::Device& device);
 
 bool ProcessEvent(SDL_Event* event);
 
-void NewFrame();
+ImGuiID NewFrame(bool is_reusing_frame = false);
 
-void Render(const vk::CommandBuffer& cmdbuf, Vulkan::Frame* frame);
+void Render(const vk::CommandBuffer& cmdbuf, const vk::ImageView& image_view,
+            const vk::Extent2D& extent);
+
+bool MustKeepDrawing(); // Force the emulator redraw
 
 } // namespace ImGui::Core

src/imgui/renderer/imgui_impl_sdl3.cpp

@@ -5,6 +5,7 @@
 
 #include <imgui.h>
 #include "common/config.h"
+#include "core/debug_state.h"
 #include "imgui_impl_sdl3.h"
 
 // SDL
@@ -26,6 +27,7 @@ struct SdlData {
     SDL_Window* window{};
     SDL_WindowID window_id{};
     Uint64 time{};
+    Uint64 nonReusedtime{};
     const char* clipboard_text_data{};
 
     // IME handling
@@ -44,6 +46,11 @@ struct SdlData {
     ImVector<SDL_Gamepad*> gamepads{};
     GamepadMode gamepad_mode{};
     bool want_update_gamepads_list{};
+
+    // Framerate counting (based on ImGui impl)
+    std::array<float, 60> framerateSecPerFrame;
+    int framerateSecPerFrameIdx{};
+    float framerateSecPerFrameAcc{};
 };
 
 // Backend data stored in io.BackendPlatformUserData to allow support for multiple Dear ImGui
@@ -785,7 +792,7 @@ static void UpdateGamepads() {
                         +thumb_dead_zone, +32767);
 }
 
-void NewFrame() {
+void NewFrame(bool is_reusing_frame) {
     SdlData* bd = GetBackendData();
     IM_ASSERT(bd != nullptr && "No platform backend to shutdown, or already shutdown?");
     ImGuiIO& io = ImGui::GetIO();
@@ -798,9 +805,29 @@ void NewFrame() {
     if (current_time <= bd->time)
         current_time = bd->time + 1;
     io.DeltaTime = bd->time > 0 ? (float)((double)(current_time - bd->time) / (double)frequency)
-                                : (float)(1.0f / 60.0f);
+                                : 1.0f / 60.0f;
     bd->time = current_time;
 
+    if (!is_reusing_frame) {
+        if (current_time <= bd->nonReusedtime)
+            current_time = bd->nonReusedtime + 1;
+        float deltaTime =
+            bd->nonReusedtime > 0
+                ? (float)((double)(current_time - bd->nonReusedtime) / (double)frequency)
+                : 1.0f / 60.0f;
+        bd->nonReusedtime = current_time;
+        DebugState.FrameDeltaTime = deltaTime;
+
+        int& frameIdx = bd->framerateSecPerFrameIdx;
+        float& framerateSec = bd->framerateSecPerFrame[frameIdx];
+        float& acc = bd->framerateSecPerFrameAcc;
+        int count = bd->framerateSecPerFrame.size();
+        acc += deltaTime - framerateSec;
+        framerateSec = deltaTime;
+        frameIdx = (frameIdx + 1) % count;
+        DebugState.Framerate = acc > 0.0f ? 1.0f / (acc / (float)count) : FLT_MAX;
+    }
+
     if (bd->mouse_pending_leave_frame && bd->mouse_pending_leave_frame >= ImGui::GetFrameCount() &&
         bd->mouse_buttons_down == 0) {
         bd->mouse_window_id = 0;

src/imgui/renderer/imgui_impl_sdl3.h

@@ -14,7 +14,7 @@ namespace ImGui::Sdl {
 
 bool Init(SDL_Window* window);
 void Shutdown();
-void NewFrame();
+void NewFrame(bool is_reusing);
 bool ProcessEvent(const SDL_Event* event);
 void OnResize();
 

src/imgui/renderer/imgui_impl_vulkan.cpp

@@ -57,11 +57,12 @@ struct VkData {
     vk::DeviceMemory font_memory{};
     vk::Image font_image{};
     vk::ImageView font_view{};
-    vk::DescriptorSet font_descriptor_set{};
+    ImTextureID font_texture{};
     vk::CommandBuffer font_command_buffer{};
 
     // Render buffers
     WindowRenderBuffers render_buffers{};
+    bool enabled_blending{true};
 
     VkData(const InitInfo init_info) : init_info(init_info) {
         render_buffers.count = init_info.image_count;
@@ -252,8 +253,8 @@ void UploadTextureData::Destroy() {
     const InitInfo& v = bd->init_info;
 
     CheckVkErr(v.device.waitIdle());
-    RemoveTexture(descriptor_set);
-    descriptor_set = VK_NULL_HANDLE;
+    RemoveTexture(im_texture);
+    im_texture = nullptr;
 
     v.device.destroyImageView(image_view, v.allocator);
     image_view = VK_NULL_HANDLE;
@@ -264,8 +265,8 @@ void UploadTextureData::Destroy() {
 }
 
 // Register a texture
-vk::DescriptorSet AddTexture(vk::ImageView image_view, vk::ImageLayout image_layout,
-                             vk::Sampler sampler) {
+ImTextureID AddTexture(vk::ImageView image_view, vk::ImageLayout image_layout,
+                       vk::Sampler sampler) {
     VkData* bd = GetBackendData();
     const InitInfo& v = bd->init_info;
 
@@ -303,7 +304,9 @@ vk::DescriptorSet AddTexture(vk::ImageView image_view, vk::ImageLayout image_lay
         };
         v.device.updateDescriptorSets({write_desc}, {});
     }
-    return descriptor_set;
+    return new Texture{
+        .descriptor_set = descriptor_set,
+    };
 }
 UploadTextureData UploadTexture(const void* data, vk::Format format, u32 width, u32 height,
                                 size_t size) {
@@ -370,7 +373,7 @@ UploadTextureData UploadTexture(const void* data, vk::Format format, u32 width,
     }
 
     // Create descriptor set (ImTextureID)
-    info.descriptor_set = AddTexture(info.image_view, vk::ImageLayout::eShaderReadOnlyOptimal);
+    info.im_texture = AddTexture(info.image_view, vk::ImageLayout::eShaderReadOnlyOptimal);
 
     // Create Upload Buffer
     {
@@ -464,10 +467,12 @@ UploadTextureData UploadTexture(const void* data, vk::Format format, u32 width,
     return info;
 }
 
-void RemoveTexture(vk::DescriptorSet descriptor_set) {
+void RemoveTexture(ImTextureID texture) {
+    IM_ASSERT(texture != nullptr);
     VkData* bd = GetBackendData();
     const InitInfo& v = bd->init_info;
-    v.device.freeDescriptorSets(bd->descriptor_pool, {descriptor_set});
+    v.device.freeDescriptorSets(bd->descriptor_pool, {texture->descriptor_set});
+    delete texture;
 }
 
 static void CreateOrResizeBuffer(RenderBuffer& rb, size_t new_size, vk::BufferUsageFlagBits usage) {
@@ -679,13 +684,7 @@ void RenderDrawData(ImDrawData& draw_data, vk::CommandBuffer command_buffer,
                 command_buffer.setScissor(0, 1, &scissor);
 
                 // Bind DescriptorSet with font or user texture
-                vk::DescriptorSet desc_set[1]{(VkDescriptorSet)pcmd->TextureId};
-                if (sizeof(ImTextureID) < sizeof(ImU64)) {
-                    // We don't support texture switches if ImTextureID hasn't been redefined to be
-                    // 64-bit. Do a flaky check that other textures haven't been used.
-                    IM_ASSERT(pcmd->TextureId == (ImTextureID)bd->font_descriptor_set);
-                    desc_set[0] = bd->font_descriptor_set;
-                }
+                vk::DescriptorSet desc_set[1]{pcmd->TextureId->descriptor_set};
                 command_buffer.bindDescriptorSets(vk::PipelineBindPoint::eGraphics,
                                                   bd->pipeline_layout, 0, {desc_set}, {});
 
@@ -709,7 +708,7 @@ static bool CreateFontsTexture() {
     const InitInfo& v = bd->init_info;
 
     // Destroy existing texture (if any)
-    if (bd->font_view || bd->font_image || bd->font_memory || bd->font_descriptor_set) {
+    if (bd->font_view || bd->font_image || bd->font_memory || bd->font_texture) {
         CheckVkErr(v.queue.waitIdle());
         DestroyFontsTexture();
     }
@@ -782,7 +781,7 @@ static bool CreateFontsTexture() {
     }
 
     // Create the Descriptor Set:
-    bd->font_descriptor_set = AddTexture(bd->font_view, vk::ImageLayout::eShaderReadOnlyOptimal);
+    bd->font_texture = AddTexture(bd->font_view, vk::ImageLayout::eShaderReadOnlyOptimal);
 
     // Create the Upload Buffer:
     vk::DeviceMemory upload_buffer_memory{};
@@ -874,7 +873,7 @@ static bool CreateFontsTexture() {
     }
 
     // Store our identifier
-    io.Fonts->SetTexID(bd->font_descriptor_set);
+    io.Fonts->SetTexID(bd->font_texture);
 
     // End command buffer
     vk::SubmitInfo end_info = {};
@@ -898,9 +897,9 @@ static void DestroyFontsTexture() {
     VkData* bd = GetBackendData();
     const InitInfo& v = bd->init_info;
 
-    if (bd->font_descriptor_set) {
-        RemoveTexture(bd->font_descriptor_set);
-        bd->font_descriptor_set = VK_NULL_HANDLE;
+    if (bd->font_texture) {
+        RemoveTexture(bd->font_texture);
+        bd->font_texture = nullptr;
         io.Fonts->SetTexID(nullptr);
     }
 

src/imgui/renderer/imgui_impl_vulkan.h

@@ -10,6 +10,12 @@
 
 struct ImDrawData;
 
+namespace ImGui {
+struct Texture {
+    vk::DescriptorSet descriptor_set{nullptr};
+};
+} // namespace ImGui
+
 namespace ImGui::Vulkan {
 
 struct InitInfo {
@@ -34,29 +40,32 @@ struct InitInfo {
 struct UploadTextureData {
     vk::Image image;
     vk::ImageView image_view;
-    vk::DescriptorSet descriptor_set;
     vk::DeviceMemory image_memory;
 
     vk::CommandBuffer command_buffer; // Submit to the queue
     vk::Buffer upload_buffer;
     vk::DeviceMemory upload_buffer_memory;
 
+    ImTextureID im_texture;
+
     void Upload();
 
     void Destroy();
 };
 
-vk::DescriptorSet AddTexture(vk::ImageView image_view, vk::ImageLayout image_layout,
-                             vk::Sampler sampler = VK_NULL_HANDLE);
+ImTextureID AddTexture(vk::ImageView image_view, vk::ImageLayout image_layout,
+                       vk::Sampler sampler = VK_NULL_HANDLE);
 
 UploadTextureData UploadTexture(const void* data, vk::Format format, u32 width, u32 height,
                                 size_t size);
 
-void RemoveTexture(vk::DescriptorSet descriptor_set);
+void RemoveTexture(ImTextureID descriptor_set);
 
 bool Init(InitInfo info);
 void Shutdown();
 void RenderDrawData(ImDrawData& draw_data, vk::CommandBuffer command_buffer,
                     vk::Pipeline pipeline = VK_NULL_HANDLE);
 
+void SetBlendEnabled(bool enabled);
+
 } // namespace ImGui::Vulkan

src/imgui/renderer/texture_manager.cpp

@@ -4,6 +4,7 @@
 #include <deque>
 #include <utility>
 
+#include <imgui.h>
 #include "common/assert.h"
 #include "common/config.h"
 #include "common/io_file.h"
@@ -123,7 +124,7 @@ static std::deque<UploadJob> g_upload_list;
 namespace Core::TextureManager {
 
 Inner::~Inner() {
-    if (upload_data.descriptor_set != nullptr) {
+    if (upload_data.im_texture != nullptr) {
         std::unique_lock lk{g_upload_mtx};
         g_upload_list.emplace_back(UploadJob{
             .data = this->upload_data,
@@ -239,7 +240,7 @@ void Submit() {
     }
     if (upload.core != nullptr) {
         upload.core->upload_data.Upload();
-        upload.core->texture_id = upload.core->upload_data.descriptor_set;
+        upload.core->texture_id = upload.core->upload_data.im_texture;
         if (upload.core->count.fetch_sub(1) == 1) {
             delete upload.core;
         }

src/input/controller.cpp

@@ -10,6 +10,55 @@
 
 namespace Input {
 
+using Libraries::Pad::OrbisPadButtonDataOffset;
+
+void State::OnButton(OrbisPadButtonDataOffset button, bool isPressed) {
+    if (isPressed) {
+        buttonsState |= button;
+    } else {
+        buttonsState &= ~button;
+    }
+}
+
+void State::OnAxis(Axis axis, int value) {
+    const auto toggle = [&](const auto button) {
+        if (value > 0) {
+            buttonsState |= button;
+        } else {
+            buttonsState &= ~button;
+        }
+    };
+    switch (axis) {
+    case Axis::TriggerLeft:
+        toggle(OrbisPadButtonDataOffset::L2);
+        break;
+    case Axis::TriggerRight:
+        toggle(OrbisPadButtonDataOffset::R2);
+        break;
+    default:
+        break;
+    }
+    axes[static_cast<int>(axis)] = value;
+}
+
+void State::OnTouchpad(int touchIndex, bool isDown, float x, float y) {
+    touchpad[touchIndex].state = isDown;
+    touchpad[touchIndex].x = static_cast<u16>(x * 1920);
+    touchpad[touchIndex].y = static_cast<u16>(y * 941);
+}
+
+void State::OnGyro(const float gyro[3]) {
+    angularVelocity.x = gyro[0];
+    angularVelocity.y = gyro[1];
+    angularVelocity.z = gyro[2];
+}
+
+void State::OnAccel(const float accel[3]) {
+    acceleration.x = accel[0];
+    acceleration.y = accel[1];
+    acceleration.z = accel[2];
+}
+
 GameController::GameController() {
     m_states_num = 0;
     m_last_state = State();
@@ -75,45 +124,22 @@ void GameController::AddState(const State& state) {
     m_states_num++;
 }
 
-void GameController::CheckButton(int id, Libraries::Pad::OrbisPadButtonDataOffset button,
-                                 bool is_pressed) {
+void GameController::CheckButton(int id, OrbisPadButtonDataOffset button, bool is_pressed) {
     std::scoped_lock lock{m_mutex};
     auto state = GetLastState();
+
     state.time = Libraries::Kernel::sceKernelGetProcessTime();
-    if (is_pressed) {
-        state.buttonsState |= button;
-    } else {
-        state.buttonsState &= ~button;
-    }
+    state.OnButton(button, is_pressed);
 
     AddState(state);
 }
 
 void GameController::Axis(int id, Input::Axis axis, int value) {
-    using Libraries::Pad::OrbisPadButtonDataOffset;
-
     std::scoped_lock lock{m_mutex};
     auto state = GetLastState();
 
     state.time = Libraries::Kernel::sceKernelGetProcessTime();
-    int axis_id = static_cast<int>(axis);
-    state.axes[axis_id] = value;
-
-    if (axis == Input::Axis::TriggerLeft) {
-        if (value > 0) {
-            state.buttonsState |= OrbisPadButtonDataOffset::L2;
-        } else {
-            state.buttonsState &= ~OrbisPadButtonDataOffset::L2;
-        }
-    }
-
-    if (axis == Input::Axis::TriggerRight) {
-        if (value > 0) {
-            state.buttonsState |= OrbisPadButtonDataOffset::R2;
-        } else {
-            state.buttonsState &= ~OrbisPadButtonDataOffset::R2;
-        }
-    }
+    state.OnAxis(axis, value);
 
     AddState(state);
 }
@@ -124,9 +150,7 @@ void GameController::Gyro(int id, const float gyro[3]) {
     state.time = Libraries::Kernel::sceKernelGetProcessTime();
 
     // Update the angular velocity (gyro data)
-    state.angularVelocity.x = gyro[0]; // X-axis
-    state.angularVelocity.y = gyro[1]; // Y-axis
-    state.angularVelocity.z = gyro[2]; // Z-axis
+    state.OnGyro(gyro);
 
     AddState(state);
 }
@@ -136,9 +160,7 @@ void GameController::Acceleration(int id, const float acceleration[3]) {
     state.time = Libraries::Kernel::sceKernelGetProcessTime();
 
     // Update the acceleration values
-    state.acceleration.x = acceleration[0]; // X-axis
-    state.acceleration.y = acceleration[1]; // Y-axis
-    state.acceleration.z = acceleration[2]; // Z-axis
+    state.OnAccel(acceleration);
 
     AddState(state);
 }
@@ -211,62 +233,48 @@ void GameController::CalculateOrientation(Libraries::Pad::OrbisFVector3& acceler
 }
 
 void GameController::SetLightBarRGB(u8 r, u8 g, u8 b) {
-    if (m_sdl_gamepad != nullptr) {
-        SDL_SetGamepadLED(m_sdl_gamepad, r, g, b);
+    if (!m_engine) {
+        return;
     }
+    std::scoped_lock _{m_mutex};
+    m_engine->SetLightBarRGB(r, g, b);
 }
 
-bool GameController::SetVibration(u8 smallMotor, u8 largeMotor) {
-    if (m_sdl_gamepad != nullptr) {
-        return SDL_RumbleGamepad(m_sdl_gamepad, (smallMotor / 255.0f) * 0xFFFF,
-                                 (largeMotor / 255.0f) * 0xFFFF, -1);
+void GameController::SetVibration(u8 smallMotor, u8 largeMotor) {
+    if (!m_engine) {
+        return;
     }
-    return true;
+    std::scoped_lock _{m_mutex};
+    m_engine->SetVibration(smallMotor, largeMotor);
 }
 
 void GameController::SetTouchpadState(int touchIndex, bool touchDown, float x, float y) {
     if (touchIndex < 2) {
         std::scoped_lock lock{m_mutex};
         auto state = GetLastState();
-        state.time = Libraries::Kernel::sceKernelGetProcessTime();
 
-        state.touchpad[touchIndex].state = touchDown;
-        state.touchpad[touchIndex].x = static_cast<u16>(x * 1920);
-        state.touchpad[touchIndex].y = static_cast<u16>(y * 941);
+        state.time = Libraries::Kernel::sceKernelGetProcessTime();
+        state.OnTouchpad(touchIndex, touchDown, x, y);
 
         AddState(state);
     }
 }
 
-void GameController::TryOpenSDLController() {
-    if (m_sdl_gamepad == nullptr || !SDL_GamepadConnected(m_sdl_gamepad)) {
-        int gamepad_count;
-        SDL_JoystickID* gamepads = SDL_GetGamepads(&gamepad_count);
-        m_sdl_gamepad = gamepad_count > 0 ? SDL_OpenGamepad(gamepads[0]) : nullptr;
-        if (Config::getIsMotionControlsEnabled()) {
-            if (SDL_SetGamepadSensorEnabled(m_sdl_gamepad, SDL_SENSOR_GYRO, true)) {
-                gyro_poll_rate = SDL_GetGamepadSensorDataRate(m_sdl_gamepad, SDL_SENSOR_GYRO);
-                LOG_INFO(Input, "Gyro initialized, poll rate: {}", gyro_poll_rate);
-            } else {
-                LOG_ERROR(Input, "Failed to initialize gyro controls for gamepad");
-            }
-            if (SDL_SetGamepadSensorEnabled(m_sdl_gamepad, SDL_SENSOR_ACCEL, true)) {
-                accel_poll_rate = SDL_GetGamepadSensorDataRate(m_sdl_gamepad, SDL_SENSOR_ACCEL);
-                LOG_INFO(Input, "Accel initialized, poll rate: {}", accel_poll_rate);
-            } else {
-                LOG_ERROR(Input, "Failed to initialize accel controls for gamepad");
-            }
-        }
-
-        SDL_free(gamepads);
-
-        SetLightBarRGB(0, 0, 255);
+void GameController::SetEngine(std::unique_ptr<Engine> engine) {
+    std::scoped_lock _{m_mutex};
+    m_engine = std::move(engine);
+    if (m_engine) {
+        m_engine->Init();
     }
 }
 
+Engine* GameController::GetEngine() {
+    return m_engine.get();
+}
+
 u32 GameController::Poll() {
-    std::scoped_lock lock{m_mutex};
     if (m_connected) {
+        std::scoped_lock lock{m_mutex};
         auto time = Libraries::Kernel::sceKernelGetProcessTime();
         if (m_states_num == 0) {
             auto diff = (time - m_last_state.time) / 1000;

src/input/controller.h

@@ -3,12 +3,12 @@
 
 #pragma once
 
+#include <algorithm>
+#include <memory>
 #include <mutex>
 #include "common/types.h"
 #include "core/libraries/pad/pad.h"
 
-struct SDL_Gamepad;
-
 namespace Input {
 
 enum class Axis {
@@ -28,7 +28,14 @@ struct TouchpadEntry {
     u16 y{};
 };
 
-struct State {
+class State {
+public:
+    void OnButton(Libraries::Pad::OrbisPadButtonDataOffset, bool);
+    void OnAxis(Axis, int);
+    void OnTouchpad(int touchIndex, bool isDown, float x, float y);
+    void OnGyro(const float[3]);
+    void OnAccel(const float[3]);
+
     Libraries::Pad::OrbisPadButtonDataOffset buttonsState{};
     u64 time = 0;
     int axes[static_cast<int>(Axis::AxisMax)] = {128, 128, 128, 128, 0, 0};
@@ -38,9 +45,19 @@ struct State {
     Libraries::Pad::OrbisFQuaternion orientation = {0.0f, 0.0f, 0.0f, 1.0f};
 };
 
+class Engine {
+public:
+    virtual ~Engine() = default;
+    virtual void Init() = 0;
+    virtual void SetLightBarRGB(u8 r, u8 g, u8 b) = 0;
+    virtual void SetVibration(u8 smallMotor, u8 largeMotor) = 0;
+    virtual State ReadState() = 0;
+    virtual float GetAccelPollRate() const = 0;
+    virtual float GetGyroPollRate() const = 0;
+};
+
 inline int GetAxis(int min, int max, int value) {
-    int v = (255 * (value - min)) / (max - min);
-    return (v < 0 ? 0 : (v > 255 ? 255 : v));
+    return std::clamp((255 * (value - min)) / (max - min), 0, 255);
 }
 
 constexpr u32 MAX_STATES = 64;
@@ -59,13 +76,12 @@ public:
     void Gyro(int id, const float gyro[3]);
     void Acceleration(int id, const float acceleration[3]);
     void SetLightBarRGB(u8 r, u8 g, u8 b);
-    bool SetVibration(u8 smallMotor, u8 largeMotor);
+    void SetVibration(u8 smallMotor, u8 largeMotor);
     void SetTouchpadState(int touchIndex, bool touchDown, float x, float y);
-    void TryOpenSDLController();
+    void SetEngine(std::unique_ptr<Engine>);
+    Engine* GetEngine();
     u32 Poll();
 
-    float gyro_poll_rate;
-    float accel_poll_rate;
     static void CalculateOrientation(Libraries::Pad::OrbisFVector3& acceleration,
                                      Libraries::Pad::OrbisFVector3& angularVelocity,
                                      float deltaTime,
@@ -85,7 +101,7 @@ private:
     std::array<State, MAX_STATES> m_states;
     std::array<StateInternal, MAX_STATES> m_private;
 
-    SDL_Gamepad* m_sdl_gamepad = nullptr;
+    std::unique_ptr<Engine> m_engine = nullptr;
 };
 
 } // namespace Input

src/main.cpp

@@ -29,6 +29,7 @@ int main(int argc, char* argv[]) {
 
     bool has_game_argument = false;
     std::string game_path;
+    std::vector<std::string> game_args{};
 
     // Map of argument strings to lambda functions
     std::unordered_map<std::string, std::function<void(int&)>> arg_map = {
@@ -37,6 +38,9 @@ int main(int argc, char* argv[]) {
              std::cout << "Usage: shadps4 [options] <elf or eboot.bin path>\n"
                           "Options:\n"
                           "  -g, --game <path|ID>          Specify game path to launch\n"
+                          " -- ...                         Parameters passed to the game ELF. "
+                          "Needs to be at the end of the line, and everything after \"--\" is a "
+                          "game argument.\n"
                           "  -p, --patch <patch_file>      Apply specified patch file\n"
                           "  -f, --fullscreen <true|false> Specify window initial fullscreen "
                           "state. Does not overwrite the config file.\n"
@@ -126,6 +130,21 @@ int main(int argc, char* argv[]) {
             // Assume the last argument is the game file if not specified via -g/--game
             game_path = argv[i];
             has_game_argument = true;
+        } else if (std::string(argv[i]) == "--") {
+            if (i + 1 == argc) {
+                std::cerr << "Warning: -- is set, but no game arguments are added!\n";
+                break;
+            }
+            for (int j = i + 1; j < argc; j++) {
+                game_args.push_back(argv[j]);
+            }
+            break;
+        } else if (i + 1 < argc && std::string(argv[i + 1]) == "--") {
+            if (!has_game_argument) {
+                game_path = argv[i];
+                has_game_argument = true;
+            }
+            break;
         } else {
             std::cerr << "Unknown argument: " << cur_arg << ", see --help for info.\n";
             return 1;
@@ -166,7 +185,7 @@ int main(int argc, char* argv[]) {
 
     // Run the emulator with the resolved eboot path
     Core::Emulator emulator;
-    emulator.Run(eboot_path);
+    emulator.Run(eboot_path, game_args);
 
     return 0;
 }

src/qt_gui/cheats_patches.cpp

@@ -188,8 +188,12 @@ void CheatsPatches::setupUI() {
         }
     });
 
+    QPushButton* closeButton = new QPushButton(tr("Close"));
+    connect(closeButton, &QPushButton::clicked, [this]() { QWidget::close(); });
+
     controlLayout->addWidget(downloadButton);
     controlLayout->addWidget(deleteCheatButton);
+    controlLayout->addWidget(closeButton);
 
     cheatsLayout->addLayout(controlLayout);
     cheatsTab->setLayout(cheatsLayout);
@@ -464,6 +468,8 @@ void CheatsPatches::onSaveButtonClicked() {
     } else {
         QMessageBox::information(this, tr("Success"), tr("Options saved successfully."));
     }
+
+    QWidget::close();
 }
 
 QCheckBox* CheatsPatches::findCheckBoxByName(const QString& name) {

src/qt_gui/main.cpp

@@ -33,6 +33,7 @@ int main(int argc, char* argv[]) {
     bool has_command_line_argument = argc > 1;
     bool show_gui = false, has_game_argument = false;
     std::string game_path;
+    std::vector<std::string> game_args{};
 
     // Map of argument strings to lambda functions
     std::unordered_map<std::string, std::function<void(int&)>> arg_map = {
@@ -43,6 +44,9 @@ int main(int argc, char* argv[]) {
                           "  No arguments: Opens the GUI.\n"
                           "  -g, --game <path|ID>          Specify <eboot.bin or elf path> or "
                           "<game ID (CUSAXXXXX)> to launch\n"
+                          " -- ...                         Parameters passed to the game ELF. "
+                          "Needs to be at the end of the line, and everything after \"--\" is a "
+                          "game argument.\n"
                           "  -p, --patch <patch_file>      Apply specified patch file\n"
                           "  -s, --show-gui                Show the GUI\n"
                           "  -f, --fullscreen <true|false> Specify window initial fullscreen "
@@ -131,6 +135,20 @@ int main(int argc, char* argv[]) {
             // Assume the last argument is the game file if not specified via -g/--game
             game_path = argv[i];
             has_game_argument = true;
+        } else if (std::string(argv[i]) == "--") {
+            if (i + 1 == argc) {
+                std::cerr << "Warning: -- is set, but no game arguments are added!\n";
+                break;
+            }
+            for (int j = i + 1; j < argc; j++) {
+                game_args.push_back(argv[j]);
+            }
+            break;
+        } else if (i + 1 < argc && std::string(argv[i + 1]) == "--") {
+            if (!has_game_argument) {
+                game_path = argv[i];
+                has_game_argument = true;
+            }
         } else {
             std::cerr << "Unknown argument: " << cur_arg << ", see --help for info.\n";
             return 1;
@@ -181,7 +199,7 @@ int main(int argc, char* argv[]) {
 
         // Run the emulator with the resolved game path
         Core::Emulator emulator;
-        emulator.Run(game_file_path.string());
+        emulator.Run(game_file_path.string(), game_args);
         if (!show_gui) {
             return 0; // Exit after running the emulator without showing the GUI
         }

src/qt_gui/main_window.cpp

@@ -247,6 +247,12 @@ void MainWindow::CreateConnects() {
         }
     });
 
+    connect(ui->shadFolderAct, &QAction::triggered, this, [this]() {
+        QString userPath;
+        Common::FS::PathToQString(userPath, Common::FS::GetUserPath(Common::FS::PathType::UserDir));
+        QDesktopServices::openUrl(QUrl::fromLocalFile(userPath));
+    });
+
     connect(ui->playButton, &QPushButton::clicked, this, &MainWindow::StartGame);
     connect(m_game_grid_frame.get(), &QTableWidget::cellDoubleClicked, this,
             &MainWindow::StartGame);
@@ -982,6 +988,7 @@ QIcon MainWindow::RecolorIcon(const QIcon& icon, bool isWhite) {
 void MainWindow::SetUiIcons(bool isWhite) {
     ui->bootInstallPkgAct->setIcon(RecolorIcon(ui->bootInstallPkgAct->icon(), isWhite));
     ui->bootGameAct->setIcon(RecolorIcon(ui->bootGameAct->icon(), isWhite));
+    ui->shadFolderAct->setIcon(RecolorIcon(ui->shadFolderAct->icon(), isWhite));
     ui->exitAct->setIcon(RecolorIcon(ui->exitAct->icon(), isWhite));
 #ifdef ENABLE_UPDATER
     ui->updaterAct->setIcon(RecolorIcon(ui->updaterAct->icon(), isWhite));

src/qt_gui/main_window_ui.h

@@ -12,6 +12,7 @@ public:
     QAction* bootInstallPkgAct;
     QAction* bootGameAct;
     QAction* addElfFolderAct;
+    QAction* shadFolderAct;
     QAction* exitAct;
     QAction* showGameListAct;
     QAction* refreshGameListAct;
@@ -89,6 +90,9 @@ public:
         addElfFolderAct = new QAction(MainWindow);
         addElfFolderAct->setObjectName("addElfFolderAct");
         addElfFolderAct->setIcon(QIcon(":images/folder_icon.png"));
+        shadFolderAct = new QAction(MainWindow);
+        shadFolderAct->setObjectName("shadFolderAct");
+        shadFolderAct->setIcon(QIcon(":images/folder_icon.png"));
         exitAct = new QAction(MainWindow);
         exitAct->setObjectName("exitAct");
         exitAct->setIcon(QIcon(":images/exit_icon.png"));
@@ -274,7 +278,9 @@ public:
         menuBar->addAction(menuHelp->menuAction());
         menuFile->addAction(bootInstallPkgAct);
         menuFile->addAction(bootGameAct);
+        menuFile->addSeparator();
         menuFile->addAction(addElfFolderAct);
+        menuFile->addAction(shadFolderAct);
         menuFile->addSeparator();
         menuFile->addAction(menuRecent->menuAction());
         menuFile->addSeparator();
@@ -333,6 +339,8 @@ public:
             "MainWindow", "Install application from a .pkg file", nullptr));
 #endif // QT_CONFIG(tooltip)
         menuRecent->setTitle(QCoreApplication::translate("MainWindow", "Recent Games", nullptr));
+        shadFolderAct->setText(
+            QCoreApplication::translate("MainWindow", "Open shadPS4 Folder", nullptr));
         exitAct->setText(QCoreApplication::translate("MainWindow", "Exit", nullptr));
 #if QT_CONFIG(tooltip)
         exitAct->setToolTip(QCoreApplication::translate("MainWindow", "Exit shadPS4", nullptr));

src/qt_gui/settings_dialog.cpp

@@ -522,22 +522,6 @@ bool SettingsDialog::eventFilter(QObject* obj, QEvent* event) {
             } else {
                 ui->descriptionText->setText(defaultTextEdit);
             }
-
-            // if the text exceeds the size of the box, it will increase the size
-            QRect currentGeometry = this->geometry();
-            int newWidth = currentGeometry.width();
-
-            int documentHeight = ui->descriptionText->document()->size().height();
-            int visibleHeight = ui->descriptionText->viewport()->height();
-            if (documentHeight > visibleHeight) {
-                ui->descriptionText->setMaximumSize(16777215, 110);
-                this->setGeometry(currentGeometry.x(), currentGeometry.y(), newWidth,
-                                  currentGeometry.height() + 40);
-            } else {
-                ui->descriptionText->setMaximumSize(16777215, 70);
-                this->setGeometry(currentGeometry.x(), currentGeometry.y(), newWidth,
-                                  initialHeight);
-            }
             return true;
         }
     }

src/qt_gui/settings_dialog.ui

@@ -12,7 +12,7 @@
     <x>0</x>
     <y>0</y>
     <width>970</width>
-    <height>750</height>
+    <height>820</height>
    </rect>
   </property>
   <property name="sizePolicy">
@@ -68,7 +68,7 @@
          <x>0</x>
          <y>0</y>
          <width>946</width>
-         <height>586</height>
+         <height>611</height>
         </rect>
        </property>
        <layout class="QVBoxLayout" name="generalTabVLayout" stretch="0">
@@ -77,43 +77,6 @@
           <property name="bottomMargin">
            <number>0</number>
           </property>
-          <item row="1" column="0">
-           <layout class="QVBoxLayout" name="systemTabLayoutLeft">
-            <item>
-             <widget class="QGroupBox" name="SystemSettings">
-              <property name="title">
-               <string>System</string>
-              </property>
-              <layout class="QVBoxLayout" name="emuSettingsLayout">
-               <item>
-                <widget class="QGroupBox" name="consoleLanguageGroupBox">
-                 <property name="title">
-                  <string>Console Language</string>
-                 </property>
-                 <layout class="QVBoxLayout" name="settingsLayout">
-                  <item>
-                   <widget class="QComboBox" name="consoleLanguageComboBox"/>
-                  </item>
-                 </layout>
-                </widget>
-               </item>
-               <item>
-                <widget class="QGroupBox" name="emulatorLanguageGroupBox">
-                 <property name="title">
-                  <string>Emulator Language</string>
-                 </property>
-                 <layout class="QVBoxLayout" name="langSettingsLayout">
-                  <item>
-                   <widget class="QComboBox" name="emulatorLanguageComboBox"/>
-                  </item>
-                 </layout>
-                </widget>
-               </item>
-              </layout>
-             </widget>
-            </item>
-           </layout>
-          </item>
           <item row="0" column="0">
            <layout class="QVBoxLayout" name="emulatorTabLayoutMiddle">
             <item>
@@ -217,246 +180,6 @@
             </item>
            </layout>
           </item>
-          <item row="1" column="2">
-           <layout class="QVBoxLayout" name="updaterTabLayoutLeft">
-            <property name="spacing">
-             <number>6</number>
-            </property>
-            <property name="sizeConstraint">
-             <enum>QLayout::SizeConstraint::SetDefaultConstraint</enum>
-            </property>
-            <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>
-            <item>
-             <widget class="QGroupBox" name="updaterGroupBox">
-              <property name="sizePolicy">
-               <sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
-                <horstretch>0</horstretch>
-                <verstretch>0</verstretch>
-               </sizepolicy>
-              </property>
-              <property name="minimumSize">
-               <size>
-                <width>0</width>
-                <height>0</height>
-               </size>
-              </property>
-              <property name="maximumSize">
-               <size>
-                <width>16777215</width>
-                <height>16777215</height>
-               </size>
-              </property>
-              <property name="title">
-               <string>Update</string>
-              </property>
-              <layout class="QVBoxLayout" name="UpdateLayout" stretch="0,0,0">
-               <property name="spacing">
-                <number>10</number>
-               </property>
-               <property name="topMargin">
-                <number>1</number>
-               </property>
-               <property name="rightMargin">
-                <number>11</number>
-               </property>
-               <property name="bottomMargin">
-                <number>11</number>
-               </property>
-               <item>
-                <widget class="QGroupBox" name="updaterComboBox">
-                 <property name="sizePolicy">
-                  <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-                   <horstretch>0</horstretch>
-                   <verstretch>0</verstretch>
-                  </sizepolicy>
-                 </property>
-                 <property name="minimumSize">
-                  <size>
-                   <width>0</width>
-                   <height>0</height>
-                  </size>
-                 </property>
-                 <property name="maximumSize">
-                  <size>
-                   <width>16777215</width>
-                   <height>16777215</height>
-                  </size>
-                 </property>
-                 <property name="title">
-                  <string>Update Channel</string>
-                 </property>
-                 <layout class="QVBoxLayout" name="UpdateChannelLayout">
-                  <property name="spacing">
-                   <number>7</number>
-                  </property>
-                  <property name="leftMargin">
-                   <number>11</number>
-                  </property>
-                  <property name="topMargin">
-                   <number>11</number>
-                  </property>
-                  <property name="rightMargin">
-                   <number>11</number>
-                  </property>
-                  <property name="bottomMargin">
-                   <number>11</number>
-                  </property>
-                  <item>
-                   <widget class="QComboBox" name="updateComboBox">
-                    <property name="sizePolicy">
-                     <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-                      <horstretch>0</horstretch>
-                      <verstretch>0</verstretch>
-                     </sizepolicy>
-                    </property>
-                    <item>
-                     <property name="text">
-                      <string>Release</string>
-                     </property>
-                    </item>
-                    <item>
-                     <property name="text">
-                      <string>Nightly</string>
-                     </property>
-                    </item>
-                   </widget>
-                  </item>
-                 </layout>
-                </widget>
-               </item>
-               <item>
-                <widget class="QPushButton" name="checkUpdateButton">
-                 <property name="sizePolicy">
-                  <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
-                   <horstretch>0</horstretch>
-                   <verstretch>0</verstretch>
-                  </sizepolicy>
-                 </property>
-                 <property name="minimumSize">
-                  <size>
-                   <width>0</width>
-                   <height>0</height>
-                  </size>
-                 </property>
-                 <property name="maximumSize">
-                  <size>
-                   <width>16777215</width>
-                   <height>16777215</height>
-                  </size>
-                 </property>
-                 <property name="text">
-                  <string>Check for Updates</string>
-                 </property>
-                </widget>
-               </item>
-               <item>
-                <widget class="QCheckBox" name="updateCheckBox">
-                 <property name="sizePolicy">
-                  <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-                   <horstretch>0</horstretch>
-                   <verstretch>0</verstretch>
-                  </sizepolicy>
-                 </property>
-                 <property name="font">
-                  <font>
-                   <pointsize>11</pointsize>
-                   <bold>false</bold>
-                  </font>
-                 </property>
-                 <property name="text">
-                  <string>Check for Updates at Startup</string>
-                 </property>
-                </widget>
-               </item>
-              </layout>
-             </widget>
-            </item>
-           </layout>
-          </item>
-          <item row="1" column="1">
-           <layout class="QVBoxLayout" name="CompatTabLayoutRight" stretch="0">
-            <item>
-             <widget class="QGroupBox" name="CompatgroupBox">
-              <property name="sizePolicy">
-               <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
-                <horstretch>0</horstretch>
-                <verstretch>0</verstretch>
-               </sizepolicy>
-              </property>
-              <property name="minimumSize">
-               <size>
-                <width>0</width>
-                <height>0</height>
-               </size>
-              </property>
-              <property name="title">
-               <string>Game Compatibility</string>
-              </property>
-              <layout class="QVBoxLayout" name="CompatLayout">
-               <property name="spacing">
-                <number>10</number>
-               </property>
-               <property name="topMargin">
-                <number>1</number>
-               </property>
-               <property name="bottomMargin">
-                <number>11</number>
-               </property>
-               <item>
-                <widget class="QCheckBox" name="enableCompatibilityCheckBox">
-                 <property name="text">
-                  <string>Display Compatibility Data</string>
-                 </property>
-                </widget>
-               </item>
-               <item>
-                <widget class="QCheckBox" name="checkCompatibilityOnStartupCheckBox">
-                 <property name="text">
-                  <string>Update Compatibility Database On Startup</string>
-                 </property>
-                </widget>
-               </item>
-               <item>
-                <widget class="QPushButton" name="updateCompatibilityButton">
-                 <property name="sizePolicy">
-                  <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
-                   <horstretch>0</horstretch>
-                   <verstretch>0</verstretch>
-                  </sizepolicy>
-                 </property>
-                 <property name="minimumSize">
-                  <size>
-                   <width>0</width>
-                   <height>0</height>
-                  </size>
-                 </property>
-                 <property name="maximumSize">
-                  <size>
-                   <width>16777215</width>
-                   <height>16777215</height>
-                  </size>
-                 </property>
-                 <property name="text">
-                  <string>Update Compatibility Database</string>
-                 </property>
-                </widget>
-               </item>
-              </layout>
-             </widget>
-            </item>
-           </layout>
-          </item>
           <item row="0" column="1">
            <layout class="QVBoxLayout" name="GUITabLayoutMiddle" stretch="0">
             <item>
@@ -627,6 +350,283 @@
             </item>
            </layout>
           </item>
+          <item row="1" column="0">
+           <layout class="QVBoxLayout" name="systemTabLayoutLeft">
+            <item>
+             <widget class="QGroupBox" name="SystemSettings">
+              <property name="title">
+               <string>System</string>
+              </property>
+              <layout class="QVBoxLayout" name="emuSettingsLayout">
+               <item>
+                <widget class="QGroupBox" name="consoleLanguageGroupBox">
+                 <property name="title">
+                  <string>Console Language</string>
+                 </property>
+                 <layout class="QVBoxLayout" name="settingsLayout">
+                  <item>
+                   <widget class="QComboBox" name="consoleLanguageComboBox"/>
+                  </item>
+                 </layout>
+                </widget>
+               </item>
+               <item>
+                <widget class="QGroupBox" name="emulatorLanguageGroupBox">
+                 <property name="title">
+                  <string>Emulator Language</string>
+                 </property>
+                 <layout class="QVBoxLayout" name="langSettingsLayout">
+                  <item>
+                   <widget class="QComboBox" name="emulatorLanguageComboBox"/>
+                  </item>
+                 </layout>
+                </widget>
+               </item>
+              </layout>
+             </widget>
+            </item>
+           </layout>
+          </item>
+          <item row="0" column="2">
+           <layout class="QVBoxLayout" name="updaterTabLayoutLeft">
+            <property name="spacing">
+             <number>6</number>
+            </property>
+            <property name="sizeConstraint">
+             <enum>QLayout::SizeConstraint::SetDefaultConstraint</enum>
+            </property>
+            <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>
+            <item>
+             <widget class="QGroupBox" name="updaterGroupBox">
+              <property name="sizePolicy">
+               <sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
+                <horstretch>0</horstretch>
+                <verstretch>0</verstretch>
+               </sizepolicy>
+              </property>
+              <property name="minimumSize">
+               <size>
+                <width>0</width>
+                <height>0</height>
+               </size>
+              </property>
+              <property name="maximumSize">
+               <size>
+                <width>16777215</width>
+                <height>16777215</height>
+               </size>
+              </property>
+              <property name="title">
+               <string>Update</string>
+              </property>
+              <layout class="QVBoxLayout" name="UpdateLayout" stretch="0,0,0">
+               <property name="spacing">
+                <number>10</number>
+               </property>
+               <property name="topMargin">
+                <number>1</number>
+               </property>
+               <property name="rightMargin">
+                <number>11</number>
+               </property>
+               <property name="bottomMargin">
+                <number>190</number>
+               </property>
+               <item>
+                <widget class="QGroupBox" name="updaterComboBox">
+                 <property name="sizePolicy">
+                  <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+                   <horstretch>0</horstretch>
+                   <verstretch>0</verstretch>
+                  </sizepolicy>
+                 </property>
+                 <property name="minimumSize">
+                  <size>
+                   <width>0</width>
+                   <height>0</height>
+                  </size>
+                 </property>
+                 <property name="maximumSize">
+                  <size>
+                   <width>16777215</width>
+                   <height>16777215</height>
+                  </size>
+                 </property>
+                 <property name="title">
+                  <string>Update Channel</string>
+                 </property>
+                 <layout class="QVBoxLayout" name="UpdateChannelLayout">
+                  <property name="spacing">
+                   <number>7</number>
+                  </property>
+                  <property name="leftMargin">
+                   <number>11</number>
+                  </property>
+                  <property name="topMargin">
+                   <number>11</number>
+                  </property>
+                  <property name="rightMargin">
+                   <number>11</number>
+                  </property>
+                  <property name="bottomMargin">
+                   <number>11</number>
+                  </property>
+                  <item>
+                   <widget class="QComboBox" name="updateComboBox">
+                    <property name="sizePolicy">
+                     <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+                      <horstretch>0</horstretch>
+                      <verstretch>0</verstretch>
+                     </sizepolicy>
+                    </property>
+                    <item>
+                     <property name="text">
+                      <string>Release</string>
+                     </property>
+                    </item>
+                    <item>
+                     <property name="text">
+                      <string>Nightly</string>
+                     </property>
+                    </item>
+                   </widget>
+                  </item>
+                 </layout>
+                </widget>
+               </item>
+               <item>
+                <widget class="QPushButton" name="checkUpdateButton">
+                 <property name="sizePolicy">
+                  <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
+                   <horstretch>0</horstretch>
+                   <verstretch>0</verstretch>
+                  </sizepolicy>
+                 </property>
+                 <property name="minimumSize">
+                  <size>
+                   <width>0</width>
+                   <height>0</height>
+                  </size>
+                 </property>
+                 <property name="maximumSize">
+                  <size>
+                   <width>16777215</width>
+                   <height>16777215</height>
+                  </size>
+                 </property>
+                 <property name="text">
+                  <string>Check for Updates</string>
+                 </property>
+                </widget>
+               </item>
+               <item>
+                <widget class="QCheckBox" name="updateCheckBox">
+                 <property name="sizePolicy">
+                  <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+                   <horstretch>0</horstretch>
+                   <verstretch>0</verstretch>
+                  </sizepolicy>
+                 </property>
+                 <property name="font">
+                  <font>
+                   <pointsize>11</pointsize>
+                   <bold>false</bold>
+                  </font>
+                 </property>
+                 <property name="text">
+                  <string>Check for Updates at Startup</string>
+                 </property>
+                </widget>
+               </item>
+              </layout>
+             </widget>
+            </item>
+           </layout>
+          </item>
+          <item row="1" column="1" colspan="2">
+           <layout class="QVBoxLayout" name="CompatTabLayoutRight" stretch="0">
+            <item>
+             <widget class="QGroupBox" name="CompatgroupBox">
+              <property name="sizePolicy">
+               <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+                <horstretch>0</horstretch>
+                <verstretch>0</verstretch>
+               </sizepolicy>
+              </property>
+              <property name="minimumSize">
+               <size>
+                <width>0</width>
+                <height>0</height>
+               </size>
+              </property>
+              <property name="title">
+               <string>Game Compatibility</string>
+              </property>
+              <layout class="QVBoxLayout" name="CompatLayout">
+               <property name="spacing">
+                <number>10</number>
+               </property>
+               <property name="topMargin">
+                <number>1</number>
+               </property>
+               <property name="bottomMargin">
+                <number>11</number>
+               </property>
+               <item>
+                <widget class="QCheckBox" name="enableCompatibilityCheckBox">
+                 <property name="text">
+                  <string>Display Compatibility Data</string>
+                 </property>
+                </widget>
+               </item>
+               <item>
+                <widget class="QCheckBox" name="checkCompatibilityOnStartupCheckBox">
+                 <property name="text">
+                  <string>Update Compatibility Database On Startup</string>
+                 </property>
+                </widget>
+               </item>
+               <item>
+                <widget class="QPushButton" name="updateCompatibilityButton">
+                 <property name="sizePolicy">
+                  <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
+                   <horstretch>0</horstretch>
+                   <verstretch>0</verstretch>
+                  </sizepolicy>
+                 </property>
+                 <property name="minimumSize">
+                  <size>
+                   <width>0</width>
+                   <height>0</height>
+                  </size>
+                 </property>
+                 <property name="maximumSize">
+                  <size>
+                   <width>16777215</width>
+                   <height>16777215</height>
+                  </size>
+                 </property>
+                 <property name="text">
+                  <string>Update Compatibility Database</string>
+                 </property>
+                </widget>
+               </item>
+              </layout>
+             </widget>
+            </item>
+           </layout>
+          </item>
          </layout>
         </item>
        </layout>
@@ -645,12 +645,12 @@
          <x>0</x>
          <y>0</y>
          <width>946</width>
-         <height>586</height>
+         <height>605</height>
         </rect>
        </property>
        <layout class="QVBoxLayout" name="inputTabVLayout" stretch="0,0">
         <item>
-         <layout class="QHBoxLayout" name="inputTabHLayoutTop" stretch="1,1,1">
+         <layout class="QHBoxLayout" name="inputTabHLayoutTop" stretch="1,1">
           <item>
            <layout class="QVBoxLayout" name="cursorTabLayoutLeft">
             <property name="spacing">
@@ -664,17 +664,14 @@
               <property name="title">
                <string>Cursor</string>
               </property>
-              <layout class="QVBoxLayout" name="inputCursorLayout">
-               <property name="spacing">
-                <number>0</number>
-               </property>
+              <layout class="QGridLayout" name="gridLayout_2">
                <property name="topMargin">
                 <number>11</number>
                </property>
                <property name="bottomMargin">
                 <number>11</number>
                </property>
-               <item>
+               <item row="0" column="0">
                 <widget class="QGroupBox" name="hideCursorGroupBox">
                  <property name="enabled">
                   <bool>true</bool>
@@ -701,7 +698,7 @@
                  </layout>
                 </widget>
                </item>
-               <item>
+               <item row="1" column="0">
                 <widget class="QGroupBox" name="idleTimeoutGroupBox">
                  <property name="enabled">
                   <bool>true</bool>
@@ -836,7 +833,7 @@
                   <bool>true</bool>
                  </property>
                  <property name="sizePolicy">
-                  <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+                  <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
@@ -872,6 +869,12 @@
                  <property name="enabled">
                   <bool>true</bool>
                  </property>
+                 <property name="sizePolicy">
+                  <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+                   <horstretch>0</horstretch>
+                   <verstretch>0</verstretch>
+                  </sizepolicy>
+                 </property>
                  <property name="minimumSize">
                   <size>
                    <width>0</width>
@@ -885,23 +888,6 @@
             </item>
            </layout>
           </item>
-          <item>
-           <layout class="QVBoxLayout" name="emptyTabLayoutRight">
-            <item>
-             <spacer name="emptyhorizontalSpacer">
-              <property name="orientation">
-               <enum>Qt::Orientation::Horizontal</enum>
-              </property>
-              <property name="sizeHint" stdset="0">
-               <size>
-                <width>40</width>
-                <height>20</height>
-               </size>
-              </property>
-             </spacer>
-            </item>
-           </layout>
-          </item>
          </layout>
         </item>
         <item>
@@ -943,7 +929,7 @@
          <x>0</x>
          <y>0</y>
          <width>946</width>
-         <height>586</height>
+         <height>605</height>
         </rect>
        </property>
        <layout class="QVBoxLayout" name="graphicsTabVLayout" stretch="0,0">
@@ -1124,11 +1110,14 @@
             </property>
             <item>
              <widget class="QGroupBox" name="additionalSettingsGroupBox">
+              <property name="enabled">
+               <bool>true</bool>
+              </property>
               <property name="title">
                <string>Advanced</string>
               </property>
               <property name="alignment">
-               <set>Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignVCenter</set>
+               <set>Qt::AlignmentFlag::AlignLeading|Qt::AlignmentFlag::AlignLeft|Qt::AlignmentFlag::AlignTop</set>
               </property>
               <layout class="QVBoxLayout" name="additionalSettingsLayout">
                <item>
@@ -1194,7 +1183,7 @@
          <x>0</x>
          <y>0</y>
          <width>946</width>
-         <height>586</height>
+         <height>605</height>
         </rect>
        </property>
        <layout class="QVBoxLayout" name="pathsTabLayout" stretch="0">
@@ -1233,22 +1222,6 @@
             </layout>
            </widget>
           </item>
-          <item>
-           <spacer name="horizontalSpacer">
-            <property name="orientation">
-             <enum>Qt::Orientation::Horizontal</enum>
-            </property>
-            <property name="sizeType">
-             <enum>QSizePolicy::Policy::Preferred</enum>
-            </property>
-            <property name="sizeHint" stdset="0">
-             <size>
-              <width>40</width>
-              <height>20</height>
-             </size>
-            </property>
-           </spacer>
-          </item>
          </layout>
         </item>
        </layout>
@@ -1445,10 +1418,16 @@
    </item>
    <item>
     <widget class="QTextEdit" name="descriptionText">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
      <property name="maximumSize">
       <size>
        <width>16777215</width>
-       <height>70</height>
+       <height>120</height>
       </size>
      </property>
      <property name="readOnly">

src/qt_gui/translations/ar.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>الألعاب الأخيرة</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>خروج</translation>

src/qt_gui/translations/da_DK.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Recent Games</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Exit</translation>

src/qt_gui/translations/de.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Zuletzt gespielt</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Beenden</translation>

src/qt_gui/translations/el.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Recent Games</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Exit</translation>

src/qt_gui/translations/en.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Recent Games</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Exit</translation>

src/qt_gui/translations/es_ES.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Juegos recientes</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Salir</translation>

src/qt_gui/translations/fa_IR.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>بازی های اخیر</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>خروج</translation>

src/qt_gui/translations/fi.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Viimeisimmät Pelit</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Sulje</translation>

src/qt_gui/translations/fr.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Jeux récents</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Ouvrir le dossier de shadPS4</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Fermer</translation>

src/qt_gui/translations/hu_HU.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Legutóbbi Játékok</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Kilépés</translation>

src/qt_gui/translations/id.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Recent Games</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Exit</translation>

src/qt_gui/translations/it.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Giochi Recenti</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Uscita</translation>

src/qt_gui/translations/ja_JP.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>最近のゲーム</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>終了</translation>

src/qt_gui/translations/ko_KR.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Recent Games</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Exit</translation>

src/qt_gui/translations/lt_LT.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Recent Games</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Exit</translation>

src/qt_gui/translations/nb.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Nylige spill</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Avslutt</translation>

src/qt_gui/translations/nl.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Recent Games</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Exit</translation>

src/qt_gui/translations/pl_PL.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Ostatnie gry</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Wyjdź</translation>

src/qt_gui/translations/pt_BR.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Jogos Recentes</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Abrir pasta shadPS4</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Sair</translation>
@@ -1341,4 +1345,4 @@
 			<translation>TB</translation>
 		</message>
 	</context>
-</TS>
+</TS>

src/qt_gui/translations/ro_RO.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Recent Games</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Exit</translation>

src/qt_gui/translations/ru_RU.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Недавние игры</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Выход</translation>

src/qt_gui/translations/sq.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Lojërat e fundit</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Dil</translation>

src/qt_gui/translations/sv.ts

@@ -722,6 +722,10 @@
         <source>Recent Games</source>
         <translation>Senaste spel</translation>
     </message>
+    <message>
+        <source>Open shadPS4 Folder</source>
+        <translation>Open shadPS4 Folder</translation>
+    </message>
     <message>
         <source>Exit</source>
         <translation>Avsluta</translation>

src/qt_gui/translations/tr_TR.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Son Oyunlar</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Çıkış</translation>

src/qt_gui/translations/uk_UA.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Нещодавні ігри</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Вихід</translation>

src/qt_gui/translations/vi_VN.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Recent Games</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Exit</translation>

src/qt_gui/translations/zh_CN.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>最近启动的游戏</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>退出</translation>

src/qt_gui/translations/zh_TW.ts

@@ -247,6 +247,10 @@
 			<source>Recent Games</source>
 			<translation>Recent Games</translation>
 		</message>
+		<message>
+			<source>Open shadPS4 Folder</source>
+			<translation>Open shadPS4 Folder</translation>
+		</message>
 		<message>
 			<source>Exit</source>
 			<translation>Exit</translation>

src/sdl_window.cpp

@@ -10,6 +10,7 @@
 
 #include "common/assert.h"
 #include "common/config.h"
+#include "core/libraries/kernel/time.h"
 #include "core/libraries/pad/pad.h"
 #include "imgui/renderer/imgui_core.h"
 #include "input/controller.h"
@@ -20,47 +21,200 @@
 #include <SDL3/SDL_metal.h>
 #endif
 
+namespace Input {
+
+using Libraries::Pad::OrbisPadButtonDataOffset;
+
+static OrbisPadButtonDataOffset SDLGamepadToOrbisButton(u8 button) {
+    using OPBDO = OrbisPadButtonDataOffset;
+
+    switch (button) {
+    case SDL_GAMEPAD_BUTTON_DPAD_DOWN:
+        return OPBDO::Down;
+    case SDL_GAMEPAD_BUTTON_DPAD_UP:
+        return OPBDO::Up;
+    case SDL_GAMEPAD_BUTTON_DPAD_LEFT:
+        return OPBDO::Left;
+    case SDL_GAMEPAD_BUTTON_DPAD_RIGHT:
+        return OPBDO::Right;
+    case SDL_GAMEPAD_BUTTON_SOUTH:
+        return OPBDO::Cross;
+    case SDL_GAMEPAD_BUTTON_NORTH:
+        return OPBDO::Triangle;
+    case SDL_GAMEPAD_BUTTON_WEST:
+        return OPBDO::Square;
+    case SDL_GAMEPAD_BUTTON_EAST:
+        return OPBDO::Circle;
+    case SDL_GAMEPAD_BUTTON_START:
+        return OPBDO::Options;
+    case SDL_GAMEPAD_BUTTON_TOUCHPAD:
+        return OPBDO::TouchPad;
+    case SDL_GAMEPAD_BUTTON_BACK:
+        return OPBDO::TouchPad;
+    case SDL_GAMEPAD_BUTTON_LEFT_SHOULDER:
+        return OPBDO::L1;
+    case SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER:
+        return OPBDO::R1;
+    case SDL_GAMEPAD_BUTTON_LEFT_STICK:
+        return OPBDO::L3;
+    case SDL_GAMEPAD_BUTTON_RIGHT_STICK:
+        return OPBDO::R3;
+    default:
+        return OPBDO::None;
+    }
+}
+
+static SDL_GamepadAxis InputAxisToSDL(Axis axis) {
+    switch (axis) {
+    case Axis::LeftX:
+        return SDL_GAMEPAD_AXIS_LEFTX;
+    case Axis::LeftY:
+        return SDL_GAMEPAD_AXIS_LEFTY;
+    case Axis::RightX:
+        return SDL_GAMEPAD_AXIS_RIGHTX;
+    case Axis::RightY:
+        return SDL_GAMEPAD_AXIS_RIGHTY;
+    case Axis::TriggerLeft:
+        return SDL_GAMEPAD_AXIS_LEFT_TRIGGER;
+    case Axis::TriggerRight:
+        return SDL_GAMEPAD_AXIS_RIGHT_TRIGGER;
+    default:
+        UNREACHABLE();
+    }
+}
+
+SDLInputEngine::~SDLInputEngine() {
+    if (m_gamepad) {
+        SDL_CloseGamepad(m_gamepad);
+    }
+}
+
+void SDLInputEngine::Init() {
+    if (m_gamepad) {
+        SDL_CloseGamepad(m_gamepad);
+        m_gamepad = nullptr;
+    }
+    int gamepad_count;
+    SDL_JoystickID* gamepads = SDL_GetGamepads(&gamepad_count);
+    if (!gamepads) {
+        LOG_ERROR(Input, "Cannot get gamepad list: {}", SDL_GetError());
+        return;
+    }
+    if (gamepad_count == 0) {
+        LOG_INFO(Input, "No gamepad found!");
+        SDL_free(gamepads);
+        return;
+    }
+    LOG_INFO(Input, "Got {} gamepads. Opening the first one.", gamepad_count);
+    if (!(m_gamepad = SDL_OpenGamepad(gamepads[0]))) {
+        LOG_ERROR(Input, "Failed to open gamepad 0: {}", SDL_GetError());
+        SDL_free(gamepads);
+        return;
+    }
+    if (Config::getIsMotionControlsEnabled()) {
+        if (SDL_SetGamepadSensorEnabled(m_gamepad, SDL_SENSOR_GYRO, true)) {
+            m_gyro_poll_rate = SDL_GetGamepadSensorDataRate(m_gamepad, SDL_SENSOR_GYRO);
+            LOG_INFO(Input, "Gyro initialized, poll rate: {}", m_gyro_poll_rate);
+        } else {
+            LOG_ERROR(Input, "Failed to initialize gyro controls for gamepad");
+        }
+        if (SDL_SetGamepadSensorEnabled(m_gamepad, SDL_SENSOR_ACCEL, true)) {
+            m_accel_poll_rate = SDL_GetGamepadSensorDataRate(m_gamepad, SDL_SENSOR_ACCEL);
+            LOG_INFO(Input, "Accel initialized, poll rate: {}", m_accel_poll_rate);
+        } else {
+            LOG_ERROR(Input, "Failed to initialize accel controls for gamepad");
+        };
+    }
+    SDL_free(gamepads);
+    SetLightBarRGB(0, 0, 255);
+}
+
+void SDLInputEngine::SetLightBarRGB(u8 r, u8 g, u8 b) {
+    if (m_gamepad) {
+        SDL_SetGamepadLED(m_gamepad, r, g, b);
+    }
+}
+
+void SDLInputEngine::SetVibration(u8 smallMotor, u8 largeMotor) {
+    if (m_gamepad) {
+        const auto low_freq = (smallMotor / 255.0f) * 0xFFFF;
+        const auto high_freq = (largeMotor / 255.0f) * 0xFFFF;
+        SDL_RumbleGamepad(m_gamepad, low_freq, high_freq, -1);
+    }
+}
+
+State SDLInputEngine::ReadState() {
+    State state{};
+    state.time = Libraries::Kernel::sceKernelGetProcessTime();
+
+    // Buttons
+    for (u8 i = 0; i < SDL_GAMEPAD_BUTTON_COUNT; ++i) {
+        auto orbisButton = SDLGamepadToOrbisButton(i);
+        if (orbisButton == OrbisPadButtonDataOffset::None) {
+            continue;
+        }
+        state.OnButton(orbisButton, SDL_GetGamepadButton(m_gamepad, (SDL_GamepadButton)i));
+    }
+
+    // Axes
+    for (int i = 0; i < static_cast<int>(Axis::AxisMax); ++i) {
+        const auto axis = static_cast<Axis>(i);
+        const auto value = SDL_GetGamepadAxis(m_gamepad, InputAxisToSDL(axis));
+        switch (axis) {
+        case Axis::TriggerLeft:
+        case Axis::TriggerRight:
+            state.OnAxis(axis, GetAxis(0, 0x8000, value));
+            break;
+        default:
+            state.OnAxis(axis, GetAxis(-0x8000, 0x8000, value));
+            break;
+        }
+    }
+
+    // Touchpad
+    if (SDL_GetNumGamepadTouchpads(m_gamepad) > 0) {
+        for (int finger = 0; finger < 2; ++finger) {
+            bool down;
+            float x, y;
+            if (SDL_GetGamepadTouchpadFinger(m_gamepad, 0, finger, &down, &x, &y, NULL)) {
+                state.OnTouchpad(finger, down, x, y);
+            }
+        }
+    }
+
+    // Gyro
+    if (SDL_GamepadHasSensor(m_gamepad, SDL_SENSOR_GYRO)) {
+        float gyro[3];
+        if (SDL_GetGamepadSensorData(m_gamepad, SDL_SENSOR_GYRO, gyro, 3)) {
+            state.OnGyro(gyro);
+        }
+    }
+
+    // Accel
+    if (SDL_GamepadHasSensor(m_gamepad, SDL_SENSOR_ACCEL)) {
+        float accel[3];
+        if (SDL_GetGamepadSensorData(m_gamepad, SDL_SENSOR_ACCEL, accel, 3)) {
+            state.OnAccel(accel);
+        }
+    }
+
+    return state;
+}
+
+float SDLInputEngine::GetGyroPollRate() const {
+    return m_gyro_poll_rate;
+}
+
+float SDLInputEngine::GetAccelPollRate() const {
+    return m_accel_poll_rate;
+}
+
+} // namespace Input
+
 namespace Frontend {
 
 using namespace Libraries::Pad;
 
-static OrbisPadButtonDataOffset SDLGamepadToOrbisButton(u8 button) {
-    switch (button) {
-    case SDL_GAMEPAD_BUTTON_DPAD_DOWN:
-        return OrbisPadButtonDataOffset::Down;
-    case SDL_GAMEPAD_BUTTON_DPAD_UP:
-        return OrbisPadButtonDataOffset::Up;
-    case SDL_GAMEPAD_BUTTON_DPAD_LEFT:
-        return OrbisPadButtonDataOffset::Left;
-    case SDL_GAMEPAD_BUTTON_DPAD_RIGHT:
-        return OrbisPadButtonDataOffset::Right;
-    case SDL_GAMEPAD_BUTTON_SOUTH:
-        return OrbisPadButtonDataOffset::Cross;
-    case SDL_GAMEPAD_BUTTON_NORTH:
-        return OrbisPadButtonDataOffset::Triangle;
-    case SDL_GAMEPAD_BUTTON_WEST:
-        return OrbisPadButtonDataOffset::Square;
-    case SDL_GAMEPAD_BUTTON_EAST:
-        return OrbisPadButtonDataOffset::Circle;
-    case SDL_GAMEPAD_BUTTON_START:
-        return OrbisPadButtonDataOffset::Options;
-    case SDL_GAMEPAD_BUTTON_TOUCHPAD:
-        return OrbisPadButtonDataOffset::TouchPad;
-    case SDL_GAMEPAD_BUTTON_BACK:
-        return OrbisPadButtonDataOffset::TouchPad;
-    case SDL_GAMEPAD_BUTTON_LEFT_SHOULDER:
-        return OrbisPadButtonDataOffset::L1;
-    case SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER:
-        return OrbisPadButtonDataOffset::R1;
-    case SDL_GAMEPAD_BUTTON_LEFT_STICK:
-        return OrbisPadButtonDataOffset::L3;
-    case SDL_GAMEPAD_BUTTON_RIGHT_STICK:
-        return OrbisPadButtonDataOffset::R3;
-    default:
-        return OrbisPadButtonDataOffset::None;
-    }
-}
-
 static Uint32 SDLCALL PollController(void* userdata, SDL_TimerID timer_id, Uint32 interval) {
     auto* controller = reinterpret_cast<Input::GameController*>(userdata);
     return controller->Poll();
@@ -112,7 +266,7 @@ WindowSDL::WindowSDL(s32 width_, s32 height_, Input::GameController* controller_
     SDL_SetWindowFullscreen(window, Config::getIsFullscreen());
 
     SDL_InitSubSystem(SDL_INIT_GAMEPAD);
-    controller->TryOpenSDLController();
+    controller->SetEngine(std::make_unique<Input::SDLInputEngine>());
 
 #if defined(SDL_PLATFORM_WIN32)
     window_info.type = WindowSystemType::Windows;
@@ -422,7 +576,7 @@ void WindowSDL::OnGamepadEvent(const SDL_Event* event) {
     switch (event->type) {
     case SDL_EVENT_GAMEPAD_ADDED:
     case SDL_EVENT_GAMEPAD_REMOVED:
-        controller->TryOpenSDLController();
+        controller->SetEngine(std::make_unique<Input::SDLInputEngine>());
         break;
     case SDL_EVENT_GAMEPAD_TOUCHPAD_DOWN:
     case SDL_EVENT_GAMEPAD_TOUCHPAD_UP:
@@ -433,7 +587,7 @@ void WindowSDL::OnGamepadEvent(const SDL_Event* event) {
         break;
     case SDL_EVENT_GAMEPAD_BUTTON_DOWN:
     case SDL_EVENT_GAMEPAD_BUTTON_UP: {
-        button = SDLGamepadToOrbisButton(event->gbutton.button);
+        button = Input::SDLGamepadToOrbisButton(event->gbutton.button);
         if (button == OrbisPadButtonDataOffset::None) {
             break;
         }

src/sdl_window.h

@@ -5,14 +5,32 @@
 
 #include <string>
 #include "common/types.h"
+#include "input/controller.h"
 
 struct SDL_Window;
 struct SDL_Gamepad;
 union SDL_Event;
 
 namespace Input {
-class GameController;
-}
+
+class SDLInputEngine : public Engine {
+public:
+    ~SDLInputEngine() override;
+    void Init() override;
+    void SetLightBarRGB(u8 r, u8 g, u8 b) override;
+    void SetVibration(u8 smallMotor, u8 largeMotor) override;
+    float GetGyroPollRate() const override;
+    float GetAccelPollRate() const override;
+    State ReadState() override;
+
+private:
+    SDL_Gamepad* m_gamepad = nullptr;
+
+    float m_gyro_poll_rate{};
+    float m_accel_poll_rate{};
+};
+
+} // namespace Input
 
 namespace Frontend {
 

src/shader_recompiler/backend/spirv/emit_spirv_special.cpp

@@ -24,10 +24,48 @@ void ConvertDepthMode(EmitContext& ctx) {
     ctx.OpStore(ctx.output_position, vector);
 }
 
+void ConvertPositionToClipSpace(EmitContext& ctx) {
+    const Id type{ctx.F32[1]};
+    Id position{ctx.OpLoad(ctx.F32[4], ctx.output_position)};
+    const Id x{ctx.OpCompositeExtract(type, position, 0u)};
+    const Id y{ctx.OpCompositeExtract(type, position, 1u)};
+    const Id z{ctx.OpCompositeExtract(type, position, 2u)};
+    const Id w{ctx.OpCompositeExtract(type, position, 3u)};
+    const Id xoffset_ptr{ctx.OpAccessChain(ctx.TypePointer(spv::StorageClass::PushConstant, type),
+                                           ctx.push_data_block,
+                                           ctx.ConstU32(PushData::XOffsetIndex))};
+    const Id xoffset{ctx.OpLoad(type, xoffset_ptr)};
+    const Id yoffset_ptr{ctx.OpAccessChain(ctx.TypePointer(spv::StorageClass::PushConstant, type),
+                                           ctx.push_data_block,
+                                           ctx.ConstU32(PushData::YOffsetIndex))};
+    const Id yoffset{ctx.OpLoad(type, yoffset_ptr)};
+    const Id xscale_ptr{ctx.OpAccessChain(ctx.TypePointer(spv::StorageClass::PushConstant, type),
+                                          ctx.push_data_block,
+                                          ctx.ConstU32(PushData::XScaleIndex))};
+    const Id xscale{ctx.OpLoad(type, xscale_ptr)};
+    const Id yscale_ptr{ctx.OpAccessChain(ctx.TypePointer(spv::StorageClass::PushConstant, type),
+                                          ctx.push_data_block,
+                                          ctx.ConstU32(PushData::YScaleIndex))};
+    const Id yscale{ctx.OpLoad(type, yscale_ptr)};
+    const Id vport_w =
+        ctx.Constant(type, float(std::min<u32>(ctx.profile.max_viewport_width / 2, 8_KB)));
+    const Id wnd_x = ctx.OpFAdd(type, ctx.OpFMul(type, x, xscale), xoffset);
+    const Id ndc_x = ctx.OpFSub(type, ctx.OpFDiv(type, wnd_x, vport_w), ctx.Constant(type, 1.f));
+    const Id vport_h =
+        ctx.Constant(type, float(std::min<u32>(ctx.profile.max_viewport_height / 2, 8_KB)));
+    const Id wnd_y = ctx.OpFAdd(type, ctx.OpFMul(type, y, yscale), yoffset);
+    const Id ndc_y = ctx.OpFSub(type, ctx.OpFDiv(type, wnd_y, vport_h), ctx.Constant(type, 1.f));
+    const Id vector{ctx.OpCompositeConstruct(ctx.F32[4], std::array<Id, 4>({ndc_x, ndc_y, z, w}))};
+    ctx.OpStore(ctx.output_position, vector);
+}
+
 void EmitEpilogue(EmitContext& ctx) {
     if (ctx.stage == Stage::Vertex && ctx.runtime_info.vs_info.emulate_depth_negative_one_to_one) {
         ConvertDepthMode(ctx);
     }
+    if (ctx.stage == Stage::Vertex && ctx.runtime_info.vs_info.clip_disable) {
+        ConvertPositionToClipSpace(ctx);
+    }
 }
 
 void EmitDiscard(EmitContext& ctx) {

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -395,7 +395,7 @@ void EmitContext::DefineInputs() {
             DefineVariable(U32[1], spv::BuiltIn::PatchVertices, spv::StorageClass::Input);
         primitive_id = DefineVariable(U32[1], spv::BuiltIn::PrimitiveId, spv::StorageClass::Input);
 
-        const u32 num_attrs = runtime_info.hs_info.ls_stride >> 4;
+        const u32 num_attrs = Common::AlignUp(runtime_info.hs_info.ls_stride, 16) >> 4;
         if (num_attrs > 0) {
             const Id per_vertex_type{TypeArray(F32[4], ConstU32(num_attrs))};
             // The input vertex count isn't statically known, so make length 32 (what glslang does)
@@ -409,7 +409,7 @@ void EmitContext::DefineInputs() {
         tess_coord = DefineInput(F32[3], std::nullopt, spv::BuiltIn::TessCoord);
         primitive_id = DefineVariable(U32[1], spv::BuiltIn::PrimitiveId, spv::StorageClass::Input);
 
-        const u32 num_attrs = runtime_info.vs_info.hs_output_cp_stride >> 4;
+        const u32 num_attrs = Common::AlignUp(runtime_info.vs_info.hs_output_cp_stride, 16) >> 4;
         if (num_attrs > 0) {
             const Id per_vertex_type{TypeArray(F32[4], ConstU32(num_attrs))};
             // The input vertex count isn't statically known, so make length 32 (what glslang does)
@@ -418,7 +418,7 @@ void EmitContext::DefineInputs() {
             Name(input_attr_array, "in_attrs");
         }
 
-        u32 patch_base_location = runtime_info.vs_info.hs_output_cp_stride >> 4;
+        const u32 patch_base_location = num_attrs;
         for (size_t index = 0; index < 30; ++index) {
             if (!(info.uses_patches & (1U << index))) {
                 continue;
@@ -453,7 +453,7 @@ void EmitContext::DefineOutputs() {
                 DefineVariable(type, spv::BuiltIn::CullDistance, spv::StorageClass::Output);
         }
         if (stage == Shader::Stage::Local && runtime_info.ls_info.links_with_tcs) {
-            const u32 num_attrs = runtime_info.ls_info.ls_stride >> 4;
+            const u32 num_attrs = Common::AlignUp(runtime_info.ls_info.ls_stride, 16) >> 4;
             if (num_attrs > 0) {
                 const Id type{TypeArray(F32[4], ConstU32(num_attrs))};
                 output_attr_array = DefineOutput(type, 0);
@@ -488,7 +488,7 @@ void EmitContext::DefineOutputs() {
             Decorate(output_tess_level_inner, spv::Decoration::Patch);
         }
 
-        const u32 num_attrs = runtime_info.hs_info.hs_output_cp_stride >> 4;
+        const u32 num_attrs = Common::AlignUp(runtime_info.hs_info.hs_output_cp_stride, 16) >> 4;
         if (num_attrs > 0) {
             const Id per_vertex_type{TypeArray(F32[4], ConstU32(num_attrs))};
             // The input vertex count isn't statically known, so make length 32 (what glslang does)
@@ -498,7 +498,7 @@ void EmitContext::DefineOutputs() {
             Name(output_attr_array, "out_attrs");
         }
 
-        u32 patch_base_location = runtime_info.hs_info.hs_output_cp_stride >> 4;
+        const u32 patch_base_location = num_attrs;
         for (size_t index = 0; index < 30; ++index) {
             if (!(info.uses_patches & (1U << index))) {
                 continue;
@@ -568,25 +568,34 @@ void EmitContext::DefineOutputs() {
 
 void EmitContext::DefinePushDataBlock() {
     // Create push constants block for instance steps rates
-    const Id struct_type{Name(
-        TypeStruct(U32[1], U32[1], U32[4], U32[4], U32[4], U32[4], U32[4], U32[4]), "AuxData")};
+    const Id struct_type{Name(TypeStruct(U32[1], U32[1], U32[4], U32[4], U32[4], U32[4], U32[4],
+                                         U32[4], F32[1], F32[1], F32[1], F32[1]),
+                              "AuxData")};
     Decorate(struct_type, spv::Decoration::Block);
     MemberName(struct_type, 0, "sr0");
     MemberName(struct_type, 1, "sr1");
-    MemberName(struct_type, 2, "buf_offsets0");
-    MemberName(struct_type, 3, "buf_offsets1");
-    MemberName(struct_type, 4, "ud_regs0");
-    MemberName(struct_type, 5, "ud_regs1");
-    MemberName(struct_type, 6, "ud_regs2");
-    MemberName(struct_type, 7, "ud_regs3");
+    MemberName(struct_type, Shader::PushData::BufOffsetIndex + 0, "buf_offsets0");
+    MemberName(struct_type, Shader::PushData::BufOffsetIndex + 1, "buf_offsets1");
+    MemberName(struct_type, Shader::PushData::UdRegsIndex + 0, "ud_regs0");
+    MemberName(struct_type, Shader::PushData::UdRegsIndex + 1, "ud_regs1");
+    MemberName(struct_type, Shader::PushData::UdRegsIndex + 2, "ud_regs2");
+    MemberName(struct_type, Shader::PushData::UdRegsIndex + 3, "ud_regs3");
+    MemberName(struct_type, Shader::PushData::XOffsetIndex, "xoffset");
+    MemberName(struct_type, Shader::PushData::YOffsetIndex, "yoffset");
+    MemberName(struct_type, Shader::PushData::XScaleIndex, "xscale");
+    MemberName(struct_type, Shader::PushData::YScaleIndex, "yscale");
     MemberDecorate(struct_type, 0, spv::Decoration::Offset, 0U);
     MemberDecorate(struct_type, 1, spv::Decoration::Offset, 4U);
-    MemberDecorate(struct_type, 2, spv::Decoration::Offset, 8U);
-    MemberDecorate(struct_type, 3, spv::Decoration::Offset, 24U);
-    MemberDecorate(struct_type, 4, spv::Decoration::Offset, 40U);
-    MemberDecorate(struct_type, 5, spv::Decoration::Offset, 56U);
-    MemberDecorate(struct_type, 6, spv::Decoration::Offset, 72U);
-    MemberDecorate(struct_type, 7, spv::Decoration::Offset, 88U);
+    MemberDecorate(struct_type, Shader::PushData::BufOffsetIndex + 0, spv::Decoration::Offset, 8U);
+    MemberDecorate(struct_type, Shader::PushData::BufOffsetIndex + 1, spv::Decoration::Offset, 24U);
+    MemberDecorate(struct_type, Shader::PushData::UdRegsIndex + 0, spv::Decoration::Offset, 40U);
+    MemberDecorate(struct_type, Shader::PushData::UdRegsIndex + 1, spv::Decoration::Offset, 56U);
+    MemberDecorate(struct_type, Shader::PushData::UdRegsIndex + 2, spv::Decoration::Offset, 72U);
+    MemberDecorate(struct_type, Shader::PushData::UdRegsIndex + 3, spv::Decoration::Offset, 88U);
+    MemberDecorate(struct_type, Shader::PushData::XOffsetIndex, spv::Decoration::Offset, 104U);
+    MemberDecorate(struct_type, Shader::PushData::YOffsetIndex, spv::Decoration::Offset, 108U);
+    MemberDecorate(struct_type, Shader::PushData::XScaleIndex, spv::Decoration::Offset, 112U);
+    MemberDecorate(struct_type, Shader::PushData::YScaleIndex, spv::Decoration::Offset, 116U);
     push_data_block = DefineVar(struct_type, spv::StorageClass::PushConstant);
     Name(push_data_block, "push_data");
     interfaces.push_back(push_data_block);
@@ -847,6 +856,10 @@ void EmitContext::DefineSharedMemory() {
     if (shared_memory_size == 0) {
         shared_memory_size = DefaultSharedMemSize;
     }
+
+    const u32 max_shared_memory_size = runtime_info.cs_info.max_shared_memory_size;
+    ASSERT(shared_memory_size <= max_shared_memory_size);
+
     const u32 num_elements{Common::DivCeil(shared_memory_size, 4U)};
     const Id type{TypeArray(U32[1], ConstU32(num_elements))};
     shared_memory_u32_type = TypePointer(spv::StorageClass::Workgroup, type);

src/shader_recompiler/frontend/translate/vector_alu.cpp

@@ -844,7 +844,7 @@ void Translator::V_FREXP_MANT_F64(const GcnInst& inst) {
 }
 
 void Translator::V_FRACT_F64(const GcnInst& inst) {
-    const IR::F32 src0{GetSrc64<IR::F64>(inst.src[0])};
+    const IR::F64 src0{GetSrc64<IR::F64>(inst.src[0])};
     SetDst64(inst.dst[0], ir.FPFract(src0));
 }
 

src/shader_recompiler/frontend/translate/vector_memory.cpp

@@ -164,8 +164,8 @@ void Translator::EmitVectorMemory(const GcnInst& inst) {
 }
 
 void Translator::BUFFER_LOAD(u32 num_dwords, bool is_typed, const GcnInst& inst) {
-    const auto& mtbuf = inst.control.mtbuf;
-    const bool is_ring = mtbuf.glc && mtbuf.slc;
+    const auto& mubuf = inst.control.mubuf;
+    const bool is_ring = mubuf.glc && mubuf.slc;
     const IR::VectorReg vaddr{inst.src[0].code};
     const IR::ScalarReg sharp{inst.src[2].code * 4};
     const IR::Value soffset{GetSrc(inst.src[3])};
@@ -178,22 +178,23 @@ void Translator::BUFFER_LOAD(u32 num_dwords, bool is_typed, const GcnInst& inst)
         if (is_ring) {
             return ir.CompositeConstruct(ir.GetVectorReg(vaddr), soffset);
         }
-        if (mtbuf.idxen && mtbuf.offen) {
+        if (mubuf.idxen && mubuf.offen) {
             return ir.CompositeConstruct(ir.GetVectorReg(vaddr), ir.GetVectorReg(vaddr + 1));
         }
-        if (mtbuf.idxen || mtbuf.offen) {
+        if (mubuf.idxen || mubuf.offen) {
             return ir.GetVectorReg(vaddr);
         }
         return {};
     }();
 
     IR::BufferInstInfo buffer_info{};
-    buffer_info.index_enable.Assign(mtbuf.idxen);
-    buffer_info.offset_enable.Assign(mtbuf.offen);
-    buffer_info.inst_offset.Assign(mtbuf.offset);
-    buffer_info.globally_coherent.Assign(mtbuf.glc);
-    buffer_info.system_coherent.Assign(mtbuf.slc);
+    buffer_info.index_enable.Assign(mubuf.idxen);
+    buffer_info.offset_enable.Assign(mubuf.offen);
+    buffer_info.inst_offset.Assign(mubuf.offset);
+    buffer_info.globally_coherent.Assign(mubuf.glc);
+    buffer_info.system_coherent.Assign(mubuf.slc);
     if (is_typed) {
+        const auto& mtbuf = inst.control.mtbuf;
         const auto dmft = static_cast<AmdGpu::DataFormat>(mtbuf.dfmt);
         const auto nfmt = static_cast<AmdGpu::NumberFormat>(mtbuf.nfmt);
         ASSERT(nfmt == AmdGpu::NumberFormat::Float &&
@@ -220,9 +221,11 @@ void Translator::BUFFER_LOAD_FORMAT(u32 num_dwords, const GcnInst& inst) {
     const auto& mubuf = inst.control.mubuf;
     const IR::VectorReg vaddr{inst.src[0].code};
     const IR::ScalarReg sharp{inst.src[2].code * 4};
-    ASSERT_MSG(!mubuf.offen && mubuf.offset == 0, "Offsets for image buffers are not supported");
     const IR::Value address = [&] -> IR::Value {
-        if (mubuf.idxen) {
+        if (mubuf.idxen && mubuf.offen) {
+            return ir.CompositeConstruct(ir.GetVectorReg(vaddr), ir.GetVectorReg(vaddr + 1));
+        }
+        if (mubuf.idxen || mubuf.offen) {
             return ir.GetVectorReg(vaddr);
         }
         return {};
@@ -230,13 +233,17 @@ void Translator::BUFFER_LOAD_FORMAT(u32 num_dwords, const GcnInst& inst) {
     const IR::Value soffset{GetSrc(inst.src[3])};
     ASSERT_MSG(soffset.IsImmediate() && soffset.U32() == 0, "Non immediate offset not supported");
 
-    IR::BufferInstInfo info{};
-    info.index_enable.Assign(mubuf.idxen);
+    IR::BufferInstInfo buffer_info{};
+    buffer_info.index_enable.Assign(mubuf.idxen);
+    buffer_info.offset_enable.Assign(mubuf.offen);
+    buffer_info.inst_offset.Assign(mubuf.offset);
+    buffer_info.globally_coherent.Assign(mubuf.glc);
+    buffer_info.system_coherent.Assign(mubuf.slc);
 
     const IR::Value handle =
         ir.CompositeConstruct(ir.GetScalarReg(sharp), ir.GetScalarReg(sharp + 1),
                               ir.GetScalarReg(sharp + 2), ir.GetScalarReg(sharp + 3));
-    const IR::Value value = ir.LoadBufferFormat(handle, address, info);
+    const IR::Value value = ir.LoadBufferFormat(handle, address, buffer_info);
     const IR::VectorReg dst_reg{inst.src[1].code};
     for (u32 i = 0; i < num_dwords; i++) {
         ir.SetVectorReg(dst_reg + i, IR::F32{ir.CompositeExtract(value, i)});
@@ -244,8 +251,8 @@ void Translator::BUFFER_LOAD_FORMAT(u32 num_dwords, const GcnInst& inst) {
 }
 
 void Translator::BUFFER_STORE(u32 num_dwords, bool is_typed, const GcnInst& inst) {
-    const auto& mtbuf = inst.control.mtbuf;
-    const bool is_ring = mtbuf.glc && mtbuf.slc;
+    const auto& mubuf = inst.control.mubuf;
+    const bool is_ring = mubuf.glc && mubuf.slc;
     const IR::VectorReg vaddr{inst.src[0].code};
     const IR::ScalarReg sharp{inst.src[2].code * 4};
     const IR::Value soffset{GetSrc(inst.src[3])};
@@ -259,22 +266,23 @@ void Translator::BUFFER_STORE(u32 num_dwords, bool is_typed, const GcnInst& inst
         if (is_ring) {
             return ir.CompositeConstruct(ir.GetVectorReg(vaddr), soffset);
         }
-        if (mtbuf.idxen && mtbuf.offen) {
+        if (mubuf.idxen && mubuf.offen) {
             return ir.CompositeConstruct(ir.GetVectorReg(vaddr), ir.GetVectorReg(vaddr + 1));
         }
-        if (mtbuf.idxen || mtbuf.offen) {
+        if (mubuf.idxen || mubuf.offen) {
             return ir.GetVectorReg(vaddr);
         }
         return {};
     }();
 
     IR::BufferInstInfo buffer_info{};
-    buffer_info.index_enable.Assign(mtbuf.idxen);
-    buffer_info.offset_enable.Assign(mtbuf.offen);
-    buffer_info.inst_offset.Assign(mtbuf.offset);
-    buffer_info.globally_coherent.Assign(mtbuf.glc);
-    buffer_info.system_coherent.Assign(mtbuf.slc);
+    buffer_info.index_enable.Assign(mubuf.idxen);
+    buffer_info.offset_enable.Assign(mubuf.offen);
+    buffer_info.inst_offset.Assign(mubuf.offset);
+    buffer_info.globally_coherent.Assign(mubuf.glc);
+    buffer_info.system_coherent.Assign(mubuf.slc);
     if (is_typed) {
+        const auto& mtbuf = inst.control.mtbuf;
         const auto dmft = static_cast<AmdGpu::DataFormat>(mtbuf.dfmt);
         const auto nfmt = static_cast<AmdGpu::NumberFormat>(mtbuf.nfmt);
         ASSERT(nfmt == AmdGpu::NumberFormat::Float &&
@@ -321,8 +329,12 @@ void Translator::BUFFER_STORE_FORMAT(u32 num_dwords, const GcnInst& inst) {
     const IR::Value soffset{GetSrc(inst.src[3])};
     ASSERT_MSG(soffset.IsImmediate() && soffset.U32() == 0, "Non immediate offset not supported");
 
-    IR::BufferInstInfo info{};
-    info.index_enable.Assign(mubuf.idxen);
+    IR::BufferInstInfo buffer_info{};
+    buffer_info.index_enable.Assign(mubuf.idxen);
+    buffer_info.offset_enable.Assign(mubuf.offen);
+    buffer_info.inst_offset.Assign(mubuf.offset);
+    buffer_info.globally_coherent.Assign(mubuf.glc);
+    buffer_info.system_coherent.Assign(mubuf.slc);
 
     const IR::VectorReg src_reg{inst.src[1].code};
 
@@ -338,7 +350,7 @@ void Translator::BUFFER_STORE_FORMAT(u32 num_dwords, const GcnInst& inst) {
     const IR::Value handle =
         ir.CompositeConstruct(ir.GetScalarReg(sharp), ir.GetScalarReg(sharp + 1),
                               ir.GetScalarReg(sharp + 2), ir.GetScalarReg(sharp + 3));
-    ir.StoreBufferFormat(handle, address, value, info);
+    ir.StoreBufferFormat(handle, address, value, buffer_info);
 }
 
 void Translator::BUFFER_ATOMIC(AtomicOp op, const GcnInst& inst) {
@@ -358,10 +370,12 @@ void Translator::BUFFER_ATOMIC(AtomicOp op, const GcnInst& inst) {
     const IR::U32 soffset{GetSrc(inst.src[3])};
     ASSERT_MSG(soffset.IsImmediate() && soffset.U32() == 0, "Non immediate offset not supported");
 
-    IR::BufferInstInfo info{};
-    info.index_enable.Assign(mubuf.idxen);
-    info.inst_offset.Assign(mubuf.offset);
-    info.offset_enable.Assign(mubuf.offen);
+    IR::BufferInstInfo buffer_info{};
+    buffer_info.index_enable.Assign(mubuf.idxen);
+    buffer_info.offset_enable.Assign(mubuf.offen);
+    buffer_info.inst_offset.Assign(mubuf.offset);
+    buffer_info.globally_coherent.Assign(mubuf.glc);
+    buffer_info.system_coherent.Assign(mubuf.slc);
 
     IR::Value vdata_val = ir.GetVectorReg<Shader::IR::U32>(vdata);
     const IR::Value handle =
@@ -371,27 +385,27 @@ void Translator::BUFFER_ATOMIC(AtomicOp op, const GcnInst& inst) {
     const IR::Value original_val = [&] {
         switch (op) {
         case AtomicOp::Swap:
-            return ir.BufferAtomicSwap(handle, address, vdata_val, info);
+            return ir.BufferAtomicSwap(handle, address, vdata_val, buffer_info);
         case AtomicOp::Add:
-            return ir.BufferAtomicIAdd(handle, address, vdata_val, info);
+            return ir.BufferAtomicIAdd(handle, address, vdata_val, buffer_info);
         case AtomicOp::Smin:
-            return ir.BufferAtomicIMin(handle, address, vdata_val, true, info);
+            return ir.BufferAtomicIMin(handle, address, vdata_val, true, buffer_info);
         case AtomicOp::Umin:
-            return ir.BufferAtomicIMin(handle, address, vdata_val, false, info);
+            return ir.BufferAtomicIMin(handle, address, vdata_val, false, buffer_info);
         case AtomicOp::Smax:
-            return ir.BufferAtomicIMax(handle, address, vdata_val, true, info);
+            return ir.BufferAtomicIMax(handle, address, vdata_val, true, buffer_info);
         case AtomicOp::Umax:
-            return ir.BufferAtomicIMax(handle, address, vdata_val, false, info);
+            return ir.BufferAtomicIMax(handle, address, vdata_val, false, buffer_info);
         case AtomicOp::And:
-            return ir.BufferAtomicAnd(handle, address, vdata_val, info);
+            return ir.BufferAtomicAnd(handle, address, vdata_val, buffer_info);
         case AtomicOp::Or:
-            return ir.BufferAtomicOr(handle, address, vdata_val, info);
+            return ir.BufferAtomicOr(handle, address, vdata_val, buffer_info);
         case AtomicOp::Xor:
-            return ir.BufferAtomicXor(handle, address, vdata_val, info);
+            return ir.BufferAtomicXor(handle, address, vdata_val, buffer_info);
         case AtomicOp::Inc:
-            return ir.BufferAtomicInc(handle, address, vdata_val, info);
+            return ir.BufferAtomicInc(handle, address, vdata_val, buffer_info);
         case AtomicOp::Dec:
-            return ir.BufferAtomicDec(handle, address, vdata_val, info);
+            return ir.BufferAtomicDec(handle, address, vdata_val, buffer_info);
         default:
             UNREACHABLE();
         }

src/shader_recompiler/info.h

@@ -96,11 +96,19 @@ using FMaskResourceList = boost::container::small_vector<FMaskResource, 16>;
 struct PushData {
     static constexpr u32 BufOffsetIndex = 2;
     static constexpr u32 UdRegsIndex = 4;
+    static constexpr u32 XOffsetIndex = 8;
+    static constexpr u32 YOffsetIndex = 9;
+    static constexpr u32 XScaleIndex = 10;
+    static constexpr u32 YScaleIndex = 11;
 
     u32 step0;
     u32 step1;
     std::array<u8, 32> buf_offsets;
     std::array<u32, NumUserDataRegs> ud_regs;
+    float xoffset;
+    float yoffset;
+    float xscale;
+    float yscale;
 
     void AddOffset(u32 binding, u32 offset) {
         ASSERT(offset < 256 && binding < buf_offsets.size());

src/shader_recompiler/ir/passes/constant_propagation_pass.cpp

@@ -222,9 +222,15 @@ void FoldMul(IR::Block& block, IR::Inst& inst) {
         return;
     }
     const IR::Value rhs{inst.Arg(1)};
-    if (rhs.IsImmediate() && Arg<T>(rhs) == 0) {
-        inst.ReplaceUsesWithAndRemove(IR::Value(0u));
-        return;
+    if (rhs.IsImmediate()) {
+        if (Arg<T>(rhs) == 0) {
+            inst.ReplaceUsesWithAndRemove(IR::Value(0u));
+            return;
+        }
+        if (Arg<T>(rhs) == 1) {
+            inst.ReplaceUsesWithAndRemove(inst.Arg(0));
+            return;
+        }
     }
 }
 

src/shader_recompiler/ir/passes/hull_shader_transform.cpp

@@ -349,11 +349,11 @@ static IR::F32 ReadTessControlPointAttribute(IR::U32 addr, const u32 stride, IR:
         addr = ir.IAdd(addr, ir.Imm32(off_dw));
     }
     const IR::U32 control_point_index = ir.IDiv(addr, ir.Imm32(stride));
-    const IR::U32 addr_for_attrs = TryOptimizeAddressModulo(addr, stride, ir);
-    const IR::U32 attr_index =
-        ir.ShiftRightLogical(ir.IMod(addr_for_attrs, ir.Imm32(stride)), ir.Imm32(4u));
+    const IR::U32 opt_addr = TryOptimizeAddressModulo(addr, stride, ir);
+    const IR::U32 offset = ir.IMod(opt_addr, ir.Imm32(stride));
+    const IR::U32 attr_index = ir.ShiftRightLogical(offset, ir.Imm32(4u));
     const IR::U32 comp_index =
-        ir.ShiftRightLogical(ir.BitwiseAnd(addr_for_attrs, ir.Imm32(0xFU)), ir.Imm32(2u));
+        ir.ShiftRightLogical(ir.BitwiseAnd(offset, ir.Imm32(0xFU)), ir.Imm32(2u));
     if (is_output_read_in_tcs) {
         return ir.ReadTcsGenericOuputAttribute(control_point_index, attr_index, comp_index);
     } else {
@@ -452,13 +452,13 @@ void HullShaderTransform(IR::Program& program, RuntimeInfo& runtime_info) {
                         if (off_dw > 0) {
                             addr = ir.IAdd(addr, ir.Imm32(off_dw));
                         }
-                        u32 stride = runtime_info.hs_info.hs_output_cp_stride;
+                        const u32 stride = runtime_info.hs_info.hs_output_cp_stride;
                         // Invocation ID array index is implicit, handled by SPIRV backend
-                        const IR::U32 addr_for_attrs = TryOptimizeAddressModulo(addr, stride, ir);
-                        const IR::U32 attr_index = ir.ShiftRightLogical(
-                            ir.IMod(addr_for_attrs, ir.Imm32(stride)), ir.Imm32(4u));
+                        const IR::U32 opt_addr = TryOptimizeAddressModulo(addr, stride, ir);
+                        const IR::U32 offset = ir.IMod(opt_addr, ir.Imm32(stride));
+                        const IR::U32 attr_index = ir.ShiftRightLogical(offset, ir.Imm32(4u));
                         const IR::U32 comp_index = ir.ShiftRightLogical(
-                            ir.BitwiseAnd(addr_for_attrs, ir.Imm32(0xFU)), ir.Imm32(2u));
+                            ir.BitwiseAnd(offset, ir.Imm32(0xFU)), ir.Imm32(2u));
                         ir.SetTcsGenericAttribute(data_component, attr_index, comp_index);
                     } else {
                         ASSERT(output_kind == AttributeRegion::PatchConst);
@@ -535,8 +535,7 @@ void HullShaderTransform(IR::Program& program, RuntimeInfo& runtime_info) {
         // ...
         IR::IREmitter ir{*entry_block, it};
 
-        ASSERT(runtime_info.hs_info.ls_stride % 16 == 0);
-        u32 num_attributes = runtime_info.hs_info.ls_stride / 16;
+        u32 num_attributes = Common::AlignUp(runtime_info.hs_info.ls_stride, 16) >> 4;
         const auto invocation_id = ir.GetAttributeU32(IR::Attribute::InvocationId);
         for (u32 attr_no = 0; attr_no < num_attributes; attr_no++) {
             for (u32 comp = 0; comp < 4; comp++) {

src/shader_recompiler/ir/passes/resource_tracking_pass.cpp

@@ -164,6 +164,7 @@ public:
             return desc.sharp_idx == existing.sharp_idx && desc.is_array == existing.is_array;
         })};
         auto& image = image_resources[index];
+        image.is_atomic |= desc.is_atomic;
         image.is_written |= desc.is_written;
         return index;
     }
@@ -483,55 +484,73 @@ void PatchDataRingAccess(IR::Block& block, IR::Inst& inst, Info& info, Descripto
     inst.SetArg(1, ir.Imm32(binding));
 }
 
+IR::U32 CalculateBufferAddress(IR::IREmitter& ir, const IR::Inst& inst, const Info& info,
+                               const AmdGpu::Buffer& buffer, u32 stride) {
+    const auto inst_info = inst.Flags<IR::BufferInstInfo>();
+
+    // index = (inst_idxen ? vgpr_index : 0) + (const_add_tid_enable ? thread_id[5:0] : 0)
+    IR::U32 index = ir.Imm32(0U);
+    if (inst_info.index_enable) {
+        const IR::U32 vgpr_index{inst_info.offset_enable
+                                     ? IR::U32{ir.CompositeExtract(inst.Arg(1), 0)}
+                                     : IR::U32{inst.Arg(1)}};
+        index = ir.IAdd(index, vgpr_index);
+    }
+    if (buffer.add_tid_enable) {
+        ASSERT_MSG(info.l_stage == LogicalStage::Compute,
+                   "Thread ID buffer addressing is not supported outside of compute.");
+        const IR::U32 thread_id{ir.LaneId()};
+        index = ir.IAdd(index, thread_id);
+    }
+    // offset = (inst_offen ? vgpr_offset : 0) + inst_offset
+    IR::U32 offset = ir.Imm32(inst_info.inst_offset.Value());
+    if (inst_info.offset_enable) {
+        const IR::U32 vgpr_offset = inst_info.index_enable
+                                        ? IR::U32{ir.CompositeExtract(inst.Arg(1), 1)}
+                                        : IR::U32{inst.Arg(1)};
+        offset = ir.IAdd(offset, vgpr_offset);
+    }
+    const IR::U32 const_stride = ir.Imm32(stride);
+    IR::U32 buffer_offset;
+    if (buffer.swizzle_enable) {
+        const IR::U32 const_index_stride = ir.Imm32(buffer.GetIndexStride());
+        const IR::U32 const_element_size = ir.Imm32(buffer.GetElementSize());
+        // index_msb = index / const_index_stride
+        const IR::U32 index_msb{ir.IDiv(index, const_index_stride)};
+        // index_lsb = index % const_index_stride
+        const IR::U32 index_lsb{ir.IMod(index, const_index_stride)};
+        // offset_msb = offset / const_element_size
+        const IR::U32 offset_msb{ir.IDiv(offset, const_element_size)};
+        // offset_lsb = offset % const_element_size
+        const IR::U32 offset_lsb{ir.IMod(offset, const_element_size)};
+        // buffer_offset =
+        //     (index_msb * const_stride + offset_msb * const_element_size) * const_index_stride
+        //     + index_lsb * const_element_size + offset_lsb
+        const IR::U32 buffer_offset_msb = ir.IMul(
+            ir.IAdd(ir.IMul(index_msb, const_stride), ir.IMul(offset_msb, const_element_size)),
+            const_index_stride);
+        const IR::U32 buffer_offset_lsb =
+            ir.IAdd(ir.IMul(index_lsb, const_element_size), offset_lsb);
+        buffer_offset = ir.IAdd(buffer_offset_msb, buffer_offset_lsb);
+    } else {
+        // buffer_offset = index * const_stride + offset
+        buffer_offset = ir.IAdd(ir.IMul(index, const_stride), offset);
+    }
+    return buffer_offset;
+}
+
 void PatchBufferArgs(IR::Block& block, IR::Inst& inst, Info& info) {
     const auto handle = inst.Arg(0);
     const auto buffer_res = info.buffers[handle.U32()];
     const auto buffer = buffer_res.GetSharp(info);
 
-    ASSERT(!buffer.add_tid_enable);
-
     // Address of constant buffer reads can be calculated at IR emission time.
     if (inst.GetOpcode() == IR::Opcode::ReadConstBuffer) {
         return;
     }
 
     IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
-    const auto inst_info = inst.Flags<IR::BufferInstInfo>();
-
-    const IR::U32 index_stride = ir.Imm32(buffer.index_stride);
-    const IR::U32 element_size = ir.Imm32(buffer.element_size);
-
-    // Compute address of the buffer using the stride.
-    IR::U32 address = ir.Imm32(inst_info.inst_offset.Value());
-    if (inst_info.index_enable) {
-        const IR::U32 index = inst_info.offset_enable ? IR::U32{ir.CompositeExtract(inst.Arg(1), 0)}
-                                                      : IR::U32{inst.Arg(1)};
-        if (buffer.swizzle_enable) {
-            const IR::U32 stride_index_stride =
-                ir.Imm32(static_cast<u32>(buffer.stride * buffer.index_stride));
-            const IR::U32 index_msb = ir.IDiv(index, index_stride);
-            const IR::U32 index_lsb = ir.IMod(index, index_stride);
-            address = ir.IAdd(address, ir.IAdd(ir.IMul(index_msb, stride_index_stride),
-                                               ir.IMul(index_lsb, element_size)));
-        } else {
-            address = ir.IAdd(address, ir.IMul(index, ir.Imm32(buffer.GetStride())));
-        }
-    }
-    if (inst_info.offset_enable) {
-        const IR::U32 offset = inst_info.index_enable ? IR::U32{ir.CompositeExtract(inst.Arg(1), 1)}
-                                                      : IR::U32{inst.Arg(1)};
-        if (buffer.swizzle_enable) {
-            const IR::U32 element_size_index_stride =
-                ir.Imm32(buffer.element_size * buffer.index_stride);
-            const IR::U32 offset_msb = ir.IDiv(offset, element_size);
-            const IR::U32 offset_lsb = ir.IMod(offset, element_size);
-            address = ir.IAdd(address,
-                              ir.IAdd(ir.IMul(offset_msb, element_size_index_stride), offset_lsb));
-        } else {
-            address = ir.IAdd(address, offset);
-        }
-    }
-    inst.SetArg(1, address);
+    inst.SetArg(1, CalculateBufferAddress(ir, inst, info, buffer, buffer.stride));
 }
 
 void PatchTextureBufferArgs(IR::Block& block, IR::Inst& inst, Info& info) {
@@ -539,8 +558,15 @@ void PatchTextureBufferArgs(IR::Block& block, IR::Inst& inst, Info& info) {
     const auto buffer_res = info.texture_buffers[handle.U32()];
     const auto buffer = buffer_res.GetSharp(info);
 
-    ASSERT(!buffer.swizzle_enable && !buffer.add_tid_enable);
+    // Only linear addressing with index is supported currently, since we cannot yet
+    // address with sub-texel granularity.
+    const auto inst_info = inst.Flags<IR::BufferInstInfo>();
+    ASSERT_MSG(!buffer.swizzle_enable && !inst_info.offset_enable && inst_info.inst_offset == 0,
+               "Unsupported texture buffer address mode.");
+
     IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
+    // Stride of 1 to get an index into formatted data. See above addressing limitations.
+    inst.SetArg(1, CalculateBufferAddress(ir, inst, info, buffer, 1U));
 
     if (inst.GetOpcode() == IR::Opcode::StoreBufferFormatF32) {
         const auto swizzled = ApplySwizzle(ir, inst.Arg(2), buffer.DstSelect());

src/shader_recompiler/profile.h

@@ -30,6 +30,8 @@ struct Profile {
     bool needs_manual_interpolation{};
     bool needs_lds_barriers{};
     u64 min_ssbo_alignment{};
+    u32 max_viewport_width{};
+    u32 max_viewport_height{};
 };
 
 } // namespace Shader