Fix building

This reverts commit 3fc3b5fdad.

.ci/ps4/build.sh

@@ -1,54 +0,0 @@
-#!/usr/local/bin/bash -ex
-
-# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-[ -f "ps4-toolchain.cmake" ] || cat << EOF >"ps4-toolchain.cmake"
-set(CMAKE_SYSROOT "$OO_PS4_TOOLCHAIN")
-set(CMAKE_STAGING_PREFIX "$OO_PS4_TOOLCHAIN")
-set(CMAKE_SYSTEM_NAME "OpenOrbis")
-
-set(CMAKE_C_FLAGS " -D__OPENORBIS__ -D_LIBCPP_HAS_MUSL_LIBC=1 -D_GNU_SOURCE=1 --target=x86_64-pc-freebsd12-elf -mtune=x86-64 -march=x86-64 -fPIC -funwind-tables")
-set(CMAKE_CXX_FLAGS " -D__OPENORBIS__ -D_LIBCPP_HAS_MUSL_LIBC=1 -D_GNU_SOURCE=1 --target=x86_64-pc-freebsd12-elf -mtune=x86-64 -march=x86-64 -fPIC -funwind-tables")
-
-set(CMAKE_EXE_LINKER_FLAGS "-m elf_x86_64 -pie -T $OO_PS4_TOOLCHAIN/link.x --eh-frame-hdr -L$OO_PS4_TOOLCHAIN/lib")
-set(CMAKE_C_LINK_FLAGS "-m elf_x86_64 -pie -T $OO_PS4_TOOLCHAIN/link.x --eh-frame-hdr -L$OO_PS4_TOOLCHAIN/lib")
-set(CMAKE_CXX_LINK_FLAGS "-m elf_x86_64 -pie -T $OO_PS4_TOOLCHAIN/link.x --eh-frame-hdr -L$OO_PS4_TOOLCHAIN/lib")
-
-set(CMAKE_C_COMPILER clang)
-set(CMAKE_CXX_COMPILER clang++)
-set(CMAKE_LINKER ld.lld)
-set(CMAKE_C_LINK_EXECUTABLE "<CMAKE_LINKER> <CMAKE_C_LINK_FLAGS> <OBJECTS> -o <TARGET> -lc -lkernel -lSceUserService  -lSceSysmodule -lSceNet $OO_PS4_TOOLCHAIN/lib/crt1.o <LINK_LIBRARIES>")
-set(CMAKE_CXX_LINK_EXECUTABLE "<CMAKE_LINKER> <CMAKE_CXX_LINK_FLAGS> <OBJECTS> -o <TARGET> -lc -lkernel -lc++ -lSceUserService -lSceSysmodule -lSceNet $OO_PS4_TOOLCHAIN/lib/crt1.o <LINK_LIBRARIES>")
-
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
-
-# TODO: Why does cmake not set this?
-set(CMAKE_SIZEOF_VOID_P 8)
-EOF
-
-# Normally a platform has a package manager
-# PS4 does not, atleast not in the normal sense
-export EXTRA_CMAKE_FLAGS=("${EXTRA_CMAKE_FLAGS[@]}" $@)
-cmake -S . -B build -G "Unix Makefiles" \
-    -DCMAKE_TOOLCHAIN_FILE="ps4-toolchain.cmake" \
-    -DENABLE_QT_TRANSLATION=OFF \
-    -DENABLE_CUBEB=OFF \
-    -DCMAKE_BUILD_TYPE=Release \
-    -DCMAKE_CXX_FLAGS="$ARCH_FLAGS" \
-    -DCMAKE_C_FLAGS="$ARCH_FLAGS" \
-    -DENABLE_SDL2=ON \
-    -DENABLE_LIBUSB=OFF \
-    -DENABLE_UPDATE_CHECKER=OFF \
-    -DENABLE_QT=OFF \
-    -DENABLE_OPENSSL=OFF \
-    -DENABLE_WEB_SERVICE=OFF \
-    -DUSE_DISCORD_PRESENCE=OFF \
-    -DCPMUTIL_FORCE_BUNDLED=ON \
-    -DYUZU_USE_EXTERNAL_FFMPEG=ON \
-    -DYUZU_USE_CPM=ON \
-    "${EXTRA_CMAKE_FLAGS[@]}" || exit
-cmake --build build -t yuzu-cmd_pkg -- -j8

.ci/ps4/make-toolchain.sh

@@ -1,176 +0,0 @@
-#!/usr/local/bin/bash -ex
-
-# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-# Define global vars
-# These flags are used everywhere, so let's reuse them.
-export OO_PS4_TOOLCHAIN="$PWD/prefix"
-export PREFIX="$OO_PS4_TOOLCHAIN"
-export CC="clang"
-export CXX="clang++"
-export AR="llvm-ar"
-export CFLAGS="-fPIC -DPS4 -D_LIBUNWIND_IS_BAREMETAL=1"
-export CXXFLAGS="$CFLAGS -D__STDC_VERSION__=0"
-export TARGET="x86_64-scei-ps4"
-export LLVM_ROOT="$PWD/llvm-project"
-export LLVM_PATH="$PWD/llvm-project/llvm"
-export WORK_PATH="$PWD"
-
-prepare_prefix() {
-    [ -d OpenOrbis-PS4-Toolchain ] || git clone --depth=1 https://github.com/OpenOrbis/OpenOrbis-PS4-Toolchain
-    [ -d musl ] || git clone --depth=1 https://github.com/OpenOrbis/musl
-    [ -d llvm-project ] || git clone --depth=1 --branch openorbis/20.x https://github.com/seuros/llvm-project
-    [ -d create-fself ] || git clone --depth=1 https://github.com/OpenOrbis/create-fself
-    [ -d create-gp4 ] || git clone --depth=1 https://github.com/OpenOrbis/create-gp4
-    [ -d readoelf ] || git clone --depth=1 https://github.com/OpenOrbis/readoelf
-    [ -d LibOrbisPkg ] || git clone --depth=1 https://github.com/maxton/LibOrbisPkg
-
-    mkdir -p $PREFIX "$PREFIX/bin" "$PREFIX/include"
-    [ -f "$PREFIX/include/orbis/libkernel.h" ] || cp -r OpenOrbis-PS4-Toolchain/include/* "$PREFIX/include/"
-    mkdir -p $PREFIX/usr
-    [ -L "$PREFIX/usr/include" ] || ln -s $PREFIX/include $PREFIX/usr/include || echo 1
-    [ -L "$PREFIX/usr/share" ] || ln -s $PREFIX/share $PREFIX/usr/share || echo 1
-    [ -L "$PREFIX/usr/lib" ] || ln -s $PREFIX/lib $PREFIX/usr/lib || echo 1
-    [ -L "$PREFIX/usr/bin" ] || ln -s $PREFIX/bin $PREFIX/usr/bin || echo 1
-}
-
-build_musl() {
-    mkdir -p musl-build
-    cd musl-build
-    ../musl/configure --target=$TARGET --disable-shared CC="$CC" CFLAGS="$CFLAGS" --prefix=$PREFIX
-    gmake -j8 && gmake install
-    cd ..
-}
-
-build_llvm() {
-    # Build compiler-rt
-    cmake "$LLVM_ROOT/compiler-rt" -B "$WORK_PATH/llvm-build/compiler-rt" \
-        -DCMAKE_INSTALL_PREFIX="$PREFIX" \
-        -DCMAKE_C_COMPILER="$CC" -DCMAKE_CXX_COMPILER="$CXX" \
-        -DCMAKE_C_FLAGS="$CFLAGS" -DCMAKE_CXX_FLAGS="$CXXFLAGS" \
-        -DCMAKE_ASM_COMPILER="$CC" -DCMAKE_ASM_FLAGS="$CFLAGS -x assembler-with-cpp" \
-        -DLLVM_PATH="$LLVM_PATH" -DCOMPILER_RT_DEFAULT_TARGET_TRIPLE="$TARGET" \
-        -DCOMPILER_RT_BAREMETAL_BUILD=YES -DCOMPILER_RT_BUILD_BUILTINS=ON \
-        -DCOMPILER_RT_BUILD_CRT=OFF -DCOMPILER_RT_BUILD_SANITIZERS=OFF \
-        -DCOMPILER_RT_BUILD_XRAY=OFF -DCOMPILER_RT_BUILD_LIBFUZZER=OFF \
-        -DCOMPILER_RT_BUILD_PROFILE=OFF -DCOMPILER_RT_STANDALONE_BUILD=ON
-    # Build libunwind
-    cmake "$LLVM_ROOT/libunwind" -B "$WORK_PATH/llvm-build/libunwind" \
-        -DCMAKE_INSTALL_PREFIX="$PREFIX" \
-        -DCMAKE_C_COMPILER="$CC" -DCMAKE_CXX_COMPILER="$CXX" \
-        -DCMAKE_C_FLAGS="$CFLAGS -fcxx-exceptions" -DCMAKE_CXX_FLAGS="$CXXFLAGS -fcxx-exceptions" \
-        -DCMAKE_ASM_COMPILER="$CC" -DCMAKE_ASM_FLAGS="$CFLAGS -x assembler-with-cpp" \
-        -DLLVM_PATH="$LLVM_PATH" -DLIBUNWIND_USE_COMPILER_RT=YES \
-        -DLIBUNWIND_BUILD_32_BITS=NO -DLIBUNWIND_ENABLE_STATIC=ON \
-        -DLIBUNWIND_ENABLE_SHARED=OFF -DLIBUNWIND_IS_BAREMETAL=ON
-    # Build libcxxabi
-    cmake "$LLVM_ROOT/libcxxabi" -B "$WORK_PATH/llvm-build/libcxxabi" \
-        -DCMAKE_INSTALL_PREFIX="$PREFIX" \
-        -DCMAKE_C_COMPILER="$CC" -DCMAKE_CXX_COMPILER="$CXX" \
-        -DCMAKE_C_FLAGS="$CFLAGS -D_GNU_SOURCE=1 -isysroot $PREFIX -isystem $LLVM_ROOT/libcxx/include -isystem $PREFIX/include -isystem $WORK_PATH/llvm-build/libcxx/include/c++/v1" \
-        -DCMAKE_CXX_FLAGS="$CXXFLAGS -D_GNU_SOURCE=1 -isysroot $PREFIX -isystem $LLVM_ROOT/libcxx/include -isystem $PREFIX/include -isystem $WORK_PATH/llvm-build/libcxx/include/c++/v1" \
-        -DCMAKE_ASM_COMPILER="$CC" -DCMAKE_ASM_FLAGS="$CFLAGS -x assembler-with-cpp" \
-        -DLLVM_PATH="$LLVM_PATH" -DLIBCXXABI_ENABLE_SHARED=NO \
-        -DLLVM_ENABLE_RUNTIMES="rt;libunwind" \
-        -DLIBCXXABI_ENABLE_STATIC=YES -DLIBCXXABI_ENABLE_EXCEPTIONS=YES \
-        -DLIBCXXABI_USE_COMPILER_RT=YES -DLIBCXXABI_USE_LLVM_UNWINDER=YES \
-        -DLIBCXXABI_LIBUNWIND_PATH="$LLVM_ROOT/libunwind" \
-        -DLIBCXXABI_LIBCXX_INCLUDES="$LLVM_ROOT/libcxx/include" \
-        -DLIBCXXABI_ENABLE_PIC=YES
-    # Build libcxx
-    cmake "$LLVM_ROOT/libcxx" -B "$WORK_PATH/llvm-build/libcxx" \
-        -DCMAKE_INSTALL_PREFIX="$PREFIX" \
-        -DCMAKE_C_COMPILER="$CC" -DCMAKE_CXX_COMPILER="$CXX" \
-        -DCMAKE_C_FLAGS="$CFLAGS -D_LIBCPP_HAS_MUSL_LIBC=1 -D_GNU_SOURCE=1 -isysroot $PREFIX -isystem $PREFIX/include/c++/v1 -isystem $PREFIX/include" \
-        -DCMAKE_CXX_FLAGS="$CXXFLAGS -D_LIBCPP_HAS_MUSL_LIBC=1 -D_GNU_SOURCE=1 -isysroot $PREFIX -isystem $PREFIX/include/c++/v1 -isystem $PREFIX/include" \
-        -DCMAKE_ASM_COMPILER="$CC" -DCMAKE_ASM_FLAGS="$CFLAGS -x assembler-with-cpp" \
-        -DLLVM_PATH="$LLVM_PATH" -DLIBCXX_ENABLE_RTTI=YES \
-        -DLIBCXX_HAS_MUSL_LIBC=YES -DLIBCXX_ENABLE_SHARED=NO \
-        -DLIBCXX_CXX_ABI=libcxxabi -DLIBCXX_CXX_ABI_INCLUDE_PATHS="$LLVM_ROOT/libcxxabi/include" \
-        -DLIBCXX_CXX_ABI_LIBRARY_PATH="$LLVM_ROOT/libcxxabi/build/lib"
-    
-    cmake --build "$WORK_PATH/llvm-build/compiler-rt" --parallel
-    cmake --install "$WORK_PATH/llvm-build/compiler-rt"
-
-    cmake --build "$WORK_PATH/llvm-build/libunwind" --parallel
-    cmake --install "$WORK_PATH/llvm-build/libunwind"
-
-    cmake --build "$WORK_PATH/llvm-build/libcxxabi" --parallel
-    cmake --install "$WORK_PATH/llvm-build/libcxxabi"
-
-    touch "$WORK_PATH/llvm-build/libcxx/include/c++/v1/libcxx.imp"
-    cmake --build "$WORK_PATH/llvm-build/libcxx" --parallel
-    cmake --install "$WORK_PATH/llvm-build/libcxx"
-}
-
-build_tools() {
-
-    # Build create-fself
-    cd create-fself/cmd/create-fself
-    cp go-linux.mod go.mod
-    go build -ldflags "-linkmode external -extldflags -static" -o create-fself
-    mv ./create-fself $PREFIX/bin/create-fself
-    cd ../../../
-
-    # Build create-gp4
-    cd create-gp4/cmd/create-gp4
-    go build -ldflags "-linkmode external -extldflags -static" -o create-gp4
-    mv ./create-gp4 $PREFIX/bin/create-gp4
-    cd ../../../
-
-    # Build readoelf
-    cd readoelf/cmd/readoelf
-    go build -ldflags "-linkmode external -extldflags -static" -o readoelf
-    mv ./readoelf $PREFIX/bin/readoelf
-    cd ../../../
-
-    # # Pull maxton's publishing tools (<3)
-    # # Sadly maxton has passed on, we have forked the repository and will continue to update it in the future. RIP <3
-    # cd $PREFIX/bin
-    # [ -f PkgTool.Core-linux-x64-0.2.231.zip ] || wget https://github.com/maxton/LibOrbisPkg/releases/download/v0.2/PkgTool.Core-linux-x64-0.2.231.zip
-    # [ -f PkgTool.Core ] || unzip PkgTool.Core-linux-x64-0.2.231.zip
-    # chmod +x PkgTool.Core
-}
-
-finish_prefix() {
-    as $WORK_PATH/OpenOrbis-PS4-Toolchain/src/crt/crtlib.S -o $PREFIX/lib/crtlib.o
-    cp -a $WORK_PATH/OpenOrbis-PS4-Toolchain/link.x $PREFIX/
-
-    cp -a ~/OpenOrbis/PS4Toolchain/lib/libkernel* $PREFIX/lib/
-    cp -a ~/OpenOrbis/PS4Toolchain/lib/libSce* $PREFIX/lib/
-
-    cp -a ~/OpenOrbis/PS4Toolchain/lib/libSDL* $PREFIX/lib/
-    cp -r ~/OpenOrbis/PS4Toolchain/include/SDL2 $PREFIX/include/SDL2
-
-    cp $WORK_PATH/llvm-build/compiler-rt/lib/freebsd/libclang_rt.builtins-x86_64.a $PREFIX/lib/
-
-    # Combine libc++, libc++abi and libunwind into a single archive
-    cat << EOF >"mri.txt"
-CREATE $PREFIX/lib/libc++M.a
-ADDLIB $PREFIX/lib/libunwind.a
-ADDLIB $PREFIX/lib/libc++abi.a
-ADDLIB $PREFIX/lib/libc++.a
-SAVE
-END
-EOF
-    $AR -M < mri.txt
-    cp $PREFIX/lib/libc++M.a $PREFIX/lib/libc++.a
-    # Merge compiler-rt into libc
-    cat << EOF >"mri.txt"
-CREATE $PREFIX/lib/libcM.a
-ADDLIB $PREFIX/lib/libc.a
-ADDLIB $PREFIX/lib/libclang_rt.builtins-x86_64.a
-SAVE
-END
-EOF
-    $AR -M < mri.txt
-    cp $PREFIX/lib/libcM.a $PREFIX/lib/libc.a
-    rm mri.txt
-}
-
-prepare_prefix
-build_musl
-build_llvm
-build_tools
-finish_prefix

.gitignore

@@ -63,6 +63,3 @@ artifacts
 *.AppImage*
 /install*
 vulkansdk*.exe
-
-# PS4 toolchain stuff
-ps4-toolchain.cmake

.patch/boost/0004-openorbis.patch

@@ -1,17 +0,0 @@
-diff --git a/libs/asio/include/boost/asio/detail/impl/socket_ops.ipp b/libs/asio/include/boost/asio/detail/impl/socket_ops.ipp
-index 0129511c..10fc9b04 100644
---- a/libs/asio/include/boost/asio/detail/impl/socket_ops.ipp
-+++ b/libs/asio/include/boost/asio/detail/impl/socket_ops.ipp
-@@ -15,6 +15,12 @@
- # pragma once
- #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
- 
-+// hacky fix for ps4
-+#if defined(__OPENORBIS__)
-+#  define FIONBIO 0
-+#  define FIONREAD 1
-+#endif
-+
- #include <boost/asio/detail/config.hpp>
- 
- #include <cctype>

.patch/enet/0001-openorbis.patch

@@ -1,13 +0,0 @@
-diff --git a/unix.c b/unix.c
-index 6669216..86a2faa 100644
---- a/unix.c
-+++ b/unix.c
-@@ -53,7 +53,7 @@
- #include <poll.h>
- #endif
- 
--#if !defined(HAS_SOCKLEN_T) && !defined(__socklen_t_defined)
-+#if !defined(__OPENORBIS__) && !defined(HAS_SOCKLEN_T) && !defined(__socklen_t_defined)
- typedef int socklen_t;
- #endif
- 

.patch/mbedtls/0001-aesni-fix.patch

@@ -7,7 +7,7 @@ index 754c984c79..59e27afd3e 100644
   * target flag is enabled when building the library (e.g. `gcc -mpclmul -msse2`
   * or `clang -maes -mpclmul`). */
 -#if (defined(__GNUC__) || defined(__clang__)) && defined(__AES__) && defined(__PCLMUL__)
-+#if (defined(__GNUC__) || defined(__clang__)) && !defined(_LIBCPP_HAS_MUSL_LIBC)
++#if defined(__GNUC__) || defined(__clang__)
  #define MBEDTLS_AESNI_HAVE_INTRINSICS
  #endif
  /* For 32-bit, we only support intrinsics */
@@ -25,7 +25,7 @@ index 2857068..3e104ab 100644
  #pragma GCC target ("pclmul,sse2,aes")
  #define MBEDTLS_POP_TARGET_PRAGMA
 -#elif defined(__clang__) && (__clang_major__ >= 5)
-+#elif defined(__clang__) && !defined(__OPENORBIS__)
++#elif defined(__clang__)
  #pragma clang attribute push (__attribute__((target("pclmul,sse2,aes"))), apply_to=function)
  #define MBEDTLS_POP_TARGET_PRAGMA
  #endif

.patch/mbedtls/0003-openorbis.patch

@@ -1,13 +0,0 @@
-diff --git a/library/entropy_poll.c b/library/entropy_poll.c
-index 611768c..8950ee4 100644
---- a/library/entropy_poll.c
-+++ b/library/entropy_poll.c
-@@ -118,7 +118,7 @@ static int getrandom_wrapper(void *buf, size_t buflen, unsigned int flags)
-  *
-  * Documentation: https://netbsd.gw.com/cgi-bin/man-cgi?sysctl+7
-  */
--#if (defined(__FreeBSD__) || defined(__NetBSD__)) && !defined(HAVE_GETRANDOM)
-+#if (defined(__FreeBSD__) || defined(__NetBSD__)) && !defined(HAVE_GETRANDOM) && !defined(__OPENORBIS__)
- #include <sys/param.h>
- #include <sys/sysctl.h>
- #if defined(KERN_ARND)

.patch/spirv-tools/0002-openorbis.patch

@@ -1,25 +0,0 @@
-diff --git a/source/opt/loop_dependence.cpp b/source/opt/loop_dependence.cpp
-index e41c044..a51b53b 100644
---- a/source/opt/loop_dependence.cpp
-+++ b/source/opt/loop_dependence.cpp
-@@ -12,6 +12,12 @@
- // See the License for the specific language governing permissions and
- // limitations under the License.
- 
-+// PS4: issue?
-+#ifdef __PS4__
-+#pragma clang diagnostic ignored "-Wabsolute-value"
-+#pragma clang diagnostic ignored "-Wshorten-64-to-32"
-+#endif
-+
- #include "source/opt/loop_dependence.h"
- 
- #include <functional>
-@@ -19,6 +25,7 @@
- #include <string>
- #include <utility>
- #include <vector>
-+#include <cstdlib>
- 
- #include "source/opt/instruction.h"
- #include "source/opt/scalar_analysis_nodes.h"

CMakeLists.txt

@@ -17,7 +17,6 @@ include(DownloadExternals)
 include(CMakeDependentOption)
 include(CTest)
 include(CPMUtil)
-include(OpenOrbis)
 
 DetectArchitecture()
 

CMakeModules/FindSDL2.cmake

@@ -1,391 +0,0 @@
-# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#  Copyright 2019 Amine Ben Hassouna <amine.benhassouna@gmail.com>
-#  Copyright 2000-2019 Kitware, Inc. and Contributors
-#  All rights reserved.
-
-#  Redistribution and use in source and binary forms, with or without
-#  modification, are permitted provided that the following conditions
-#  are met:
-
-#  * Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-
-#  * Redistributions in binary form must reproduce the above copyright
-#    notice, this list of conditions and the following disclaimer in the
-#    documentation and/or other materials provided with the distribution.
-
-#  * Neither the name of Kitware, Inc. nor the names of Contributors
-#    may be used to endorse or promote products derived from this
-#    software without specific prior written permission.
-
-#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-#  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-#  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-#  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-#  HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-#  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-#  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-#  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-#  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-#  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#[=======================================================================[.rst:
-FindSDL2
---------
-
-Locate SDL2 library
-
-This module defines the following 'IMPORTED' targets:
-
-::
-
-  SDL2::Core
-    The SDL2 library, if found.
-    Libraries should link to SDL2::Core
-
-  SDL2::Main
-    The SDL2main library, if found.
-    Applications should link to SDL2::Main instead of SDL2::Core
-
-
-
-This module will set the following variables in your project:
-
-::
-
-  SDL2_LIBRARIES, the name of the library to link against
-  SDL2_INCLUDE_DIRS, where to find SDL.h
-  SDL2_FOUND, if false, do not try to link to SDL2
-  SDL2MAIN_FOUND, if false, do not try to link to SDL2main
-  SDL2_VERSION_STRING, human-readable string containing the version of SDL2
-
-
-
-This module responds to the following cache variables:
-
-::
-
-  SDL2_PATH
-    Set a custom SDL2 Library path (default: empty)
-
-  SDL2_NO_DEFAULT_PATH
-    Disable search SDL2 Library in default path.
-      If SDL2_PATH (default: ON)
-      Else (default: OFF)
-
-  SDL2_INCLUDE_DIR
-    SDL2 headers path.
-
-  SDL2_LIBRARY
-    SDL2 Library (.dll, .so, .a, etc) path.
-
-  SDL2MAIN_LIBRAY
-    SDL2main Library (.a) path.
-
-  SDL2_BUILDING_LIBRARY
-    This flag is useful only when linking to SDL2_LIBRARIES insead of
-    SDL2::Main. It is required only when building a library that links to
-    SDL2_LIBRARIES, because only applications need main() (No need to also
-    link to SDL2main).
-    If this flag is defined, then no SDL2main will be added to SDL2_LIBRARIES
-    and no SDL2::Main target will be created.
-
-
-Don't forget to include SDLmain.h and SDLmain.m in your project for the
-OS X framework based version. (Other versions link to -lSDL2main which
-this module will try to find on your behalf.) Also for OS X, this
-module will automatically add the -framework Cocoa on your behalf.
-
-
-Additional Note: If you see an empty SDL2_LIBRARY in your project
-configuration, it means CMake did not find your SDL2 library
-(SDL2.dll, libsdl2.so, SDL2.framework, etc). Set SDL2_LIBRARY to point
-to your SDL2 library, and  configure again. Similarly, if you see an
-empty SDL2MAIN_LIBRARY, you should set this value as appropriate. These
-values are used to generate the final SDL2_LIBRARIES variable and the
-SDL2::Core and SDL2::Main targets, but when these values are unset,
-SDL2_LIBRARIES, SDL2::Core and SDL2::Main does not get created.
-
-
-$SDL2DIR is an environment variable that would correspond to the
-./configure --prefix=$SDL2DIR used in building SDL2.  l.e.galup 9-20-02
-
-
-
-Created by Amine Ben Hassouna:
-  Adapt FindSDL.cmake to SDL2 (FindSDL2.cmake).
-  Add cache variables for more flexibility:
-    SDL2_PATH, SDL2_NO_DEFAULT_PATH (for details, see doc above).
-  Mark 'Threads' as a required dependency for non-OSX systems.
-  Modernize the FindSDL2.cmake module by creating specific targets:
-    SDL2::Core and SDL2::Main (for details, see doc above).
-
-
-Original FindSDL.cmake module:
-  Modified by Eric Wing.  Added code to assist with automated building
-  by using environmental variables and providing a more
-  controlled/consistent search behavior.  Added new modifications to
-  recognize OS X frameworks and additional Unix paths (FreeBSD, etc).
-  Also corrected the header search path to follow "proper" SDL
-  guidelines.  Added a search for SDLmain which is needed by some
-  platforms.  Added a search for threads which is needed by some
-  platforms.  Added needed compile switches for MinGW.
-
-On OSX, this will prefer the Framework version (if found) over others.
-People will have to manually change the cache value of SDL2_LIBRARY to
-override this selection or set the SDL2_PATH variable or the CMake
-environment CMAKE_INCLUDE_PATH to modify the search paths.
-
-Note that the header path has changed from SDL/SDL.h to just SDL.h
-This needed to change because "proper" SDL convention is #include
-"SDL.h", not <SDL/SDL.h>.  This is done for portability reasons
-because not all systems place things in SDL/ (see FreeBSD).
-#]=======================================================================]
-
-# Define options for searching SDL2 Library in a custom path
-
-set(SDL2_PATH "" CACHE STRING "Custom SDL2 Library path")
-
-set(_SDL2_NO_DEFAULT_PATH OFF)
-if(SDL2_PATH)
-  set(_SDL2_NO_DEFAULT_PATH ON)
-endif()
-
-set(SDL2_NO_DEFAULT_PATH ${_SDL2_NO_DEFAULT_PATH}
-    CACHE BOOL "Disable search SDL2 Library in default path")
-unset(_SDL2_NO_DEFAULT_PATH)
-
-set(SDL2_NO_DEFAULT_PATH_CMD)
-if(SDL2_NO_DEFAULT_PATH)
-  set(SDL2_NO_DEFAULT_PATH_CMD NO_DEFAULT_PATH)
-endif()
-
-# Search for the SDL2 include directory
-find_path(SDL2_INCLUDE_DIR SDL.h
-  HINTS
-    ENV SDL2DIR
-    ${SDL2_NO_DEFAULT_PATH_CMD}
-  PATH_SUFFIXES SDL2
-                # path suffixes to search inside ENV{SDL2DIR}
-                include/SDL2 include
-  PATHS ${SDL2_PATH}
-  DOC "Where the SDL2 headers can be found"
-)
-
-set(SDL2_INCLUDE_DIRS "${SDL2_INCLUDE_DIR}")
-
-if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-  set(VC_LIB_PATH_SUFFIX lib/x64)
-else()
-  set(VC_LIB_PATH_SUFFIX lib/x86)
-endif()
-
-# SDL-2.0 is the name used by FreeBSD ports...
-# don't confuse it for the version number.
-find_library(SDL2_LIBRARY
-  NAMES SDL2 SDL-2.0
-  HINTS
-    ENV SDL2DIR
-    ${SDL2_NO_DEFAULT_PATH_CMD}
-  PATH_SUFFIXES lib ${VC_LIB_PATH_SUFFIX}
-  PATHS ${SDL2_PATH}
-  DOC "Where the SDL2 Library can be found"
-)
-
-set(SDL2_LIBRARIES "${SDL2_LIBRARY}")
-
-if(NOT SDL2_BUILDING_LIBRARY)
-  if(NOT SDL2_INCLUDE_DIR MATCHES ".framework")
-    # Non-OS X framework versions expect you to also dynamically link to
-    # SDL2main. This is mainly for Windows and OS X. Other (Unix) platforms
-    # seem to provide SDL2main for compatibility even though they don't
-    # necessarily need it.
-
-    if(SDL2_PATH)
-      set(SDL2MAIN_LIBRARY_PATHS "${SDL2_PATH}")
-    endif()
-
-    if(NOT SDL2_NO_DEFAULT_PATH)
-      set(SDL2MAIN_LIBRARY_PATHS
-            /sw
-            /opt/local
-            /opt/csw
-            /opt
-            "${SDL2MAIN_LIBRARY_PATHS}"
-      )
-    endif()
-
-    find_library(SDL2MAIN_LIBRARY
-      NAMES SDL2main
-      HINTS
-        ENV SDL2DIR
-        ${SDL2_NO_DEFAULT_PATH_CMD}
-      PATH_SUFFIXES lib ${VC_LIB_PATH_SUFFIX}
-      PATHS ${SDL2MAIN_LIBRARY_PATHS}
-      DOC "Where the SDL2main library can be found"
-    )
-    unset(SDL2MAIN_LIBRARY_PATHS)
-  endif()
-endif()
-
-# SDL2 may require threads on your system.
-# The Apple build may not need an explicit flag because one of the
-# frameworks may already provide it.
-# But for non-OSX systems, I will use the CMake Threads package.
-if(NOT APPLE)
-  find_package(Threads QUIET)
-  if(NOT Threads_FOUND)
-    set(SDL2_THREADS_NOT_FOUND "Could NOT find Threads (Threads is required by SDL2).")
-    if(SDL2_FIND_REQUIRED)
-      message(FATAL_ERROR ${SDL2_THREADS_NOT_FOUND})
-    else()
-        if(NOT SDL2_FIND_QUIETLY)
-          message(STATUS ${SDL2_THREADS_NOT_FOUND})
-        endif()
-      return()
-    endif()
-    unset(SDL2_THREADS_NOT_FOUND)
-  endif()
-endif()
-
-# MinGW needs an additional link flag, -mwindows
-# It's total link flags should look like -lmingw32 -lSDL2main -lSDL2 -mwindows
-if(MINGW)
-  set(MINGW32_LIBRARY mingw32 "-mwindows" CACHE STRING "link flags for MinGW")
-endif()
-
-if(SDL2_LIBRARY)
-  # For SDL2main
-  if(SDL2MAIN_LIBRARY AND NOT SDL2_BUILDING_LIBRARY)
-    list(FIND SDL2_LIBRARIES "${SDL2MAIN_LIBRARY}" _SDL2_MAIN_INDEX)
-    if(_SDL2_MAIN_INDEX EQUAL -1)
-      set(SDL2_LIBRARIES "${SDL2MAIN_LIBRARY}" ${SDL2_LIBRARIES})
-    endif()
-    unset(_SDL2_MAIN_INDEX)
-  endif()
-
-  # For OS X, SDL2 uses Cocoa as a backend so it must link to Cocoa.
-  # CMake doesn't display the -framework Cocoa string in the UI even
-  # though it actually is there if I modify a pre-used variable.
-  # I think it has something to do with the CACHE STRING.
-  # So I use a temporary variable until the end so I can set the
-  # "real" variable in one-shot.
-  if(APPLE)
-    set(SDL2_LIBRARIES ${SDL2_LIBRARIES} -framework Cocoa)
-  endif()
-
-  # For threads, as mentioned Apple doesn't need this.
-  # In fact, there seems to be a problem if I used the Threads package
-  # and try using this line, so I'm just skipping it entirely for OS X.
-  if(NOT APPLE)
-    set(SDL2_LIBRARIES ${SDL2_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
-  endif()
-
-  # For MinGW library
-  if(MINGW)
-    set(SDL2_LIBRARIES ${MINGW32_LIBRARY} ${SDL2_LIBRARIES})
-  endif()
-
-endif()
-
-# Read SDL2 version
-if(SDL2_INCLUDE_DIR AND EXISTS "${SDL2_INCLUDE_DIR}/SDL_version.h")
-  file(STRINGS "${SDL2_INCLUDE_DIR}/SDL_version.h" SDL2_VERSION_MAJOR_LINE REGEX "^#define[ \t]+SDL_MAJOR_VERSION[ \t]+[0-9]+$")
-  file(STRINGS "${SDL2_INCLUDE_DIR}/SDL_version.h" SDL2_VERSION_MINOR_LINE REGEX "^#define[ \t]+SDL_MINOR_VERSION[ \t]+[0-9]+$")
-  file(STRINGS "${SDL2_INCLUDE_DIR}/SDL_version.h" SDL2_VERSION_PATCH_LINE REGEX "^#define[ \t]+SDL_PATCHLEVEL[ \t]+[0-9]+$")
-  string(REGEX REPLACE "^#define[ \t]+SDL_MAJOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_VERSION_MAJOR "${SDL2_VERSION_MAJOR_LINE}")
-  string(REGEX REPLACE "^#define[ \t]+SDL_MINOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_VERSION_MINOR "${SDL2_VERSION_MINOR_LINE}")
-  string(REGEX REPLACE "^#define[ \t]+SDL_PATCHLEVEL[ \t]+([0-9]+)$" "\\1" SDL2_VERSION_PATCH "${SDL2_VERSION_PATCH_LINE}")
-  set(SDL2_VERSION_STRING ${SDL2_VERSION_MAJOR}.${SDL2_VERSION_MINOR}.${SDL2_VERSION_PATCH})
-  unset(SDL2_VERSION_MAJOR_LINE)
-  unset(SDL2_VERSION_MINOR_LINE)
-  unset(SDL2_VERSION_PATCH_LINE)
-  unset(SDL2_VERSION_MAJOR)
-  unset(SDL2_VERSION_MINOR)
-  unset(SDL2_VERSION_PATCH)
-endif()
-
-include(FindPackageHandleStandardArgs)
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2
-                                  REQUIRED_VARS SDL2_LIBRARY SDL2_INCLUDE_DIR
-                                  VERSION_VAR SDL2_VERSION_STRING)
-
-if(SDL2MAIN_LIBRARY)
-  FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2main
-                                    REQUIRED_VARS SDL2MAIN_LIBRARY SDL2_INCLUDE_DIR
-                                    VERSION_VAR SDL2_VERSION_STRING)
-endif()
-
-
-mark_as_advanced(SDL2_PATH
-                 SDL2_NO_DEFAULT_PATH
-                 SDL2_LIBRARY
-                 SDL2MAIN_LIBRARY
-                 SDL2_INCLUDE_DIR
-                 SDL2_BUILDING_LIBRARY)
-
-
-# SDL2:: targets (SDL2::Core and SDL2::Main)
-if(SDL2_FOUND)
-
-  # SDL2::Core target
-  if(SDL2_LIBRARY AND NOT TARGET SDL2::Core)
-    add_library(SDL2::Core UNKNOWN IMPORTED)
-    set_target_properties(SDL2::Core PROPERTIES
-                          IMPORTED_LOCATION "${SDL2_LIBRARY}"
-                          INTERFACE_INCLUDE_DIRECTORIES "${SDL2_INCLUDE_DIR}")
-
-    if(APPLE)
-      # For OS X, SDL2 uses Cocoa as a backend so it must link to Cocoa.
-      # For more details, please see above.
-      set_property(TARGET SDL2::Core APPEND PROPERTY
-                   INTERFACE_LINK_OPTIONS -framework Cocoa)
-    else()
-      # For threads, as mentioned Apple doesn't need this.
-      # For more details, please see above.
-      set_property(TARGET SDL2::Core APPEND PROPERTY
-                   INTERFACE_LINK_LIBRARIES Threads::Threads)
-    endif()
-  endif()
-
-  # SDL2::Main target
-  # Applications should link to SDL2::Main instead of SDL2::Core
-  # For more details, please see above.
-  if(NOT SDL2_BUILDING_LIBRARY AND NOT TARGET SDL2::Main)
-
-    if(SDL2_INCLUDE_DIR MATCHES ".framework" OR NOT SDL2MAIN_LIBRARY)
-      add_library(SDL2::Main INTERFACE IMPORTED)
-      set_property(TARGET SDL2::Main PROPERTY
-                   INTERFACE_LINK_LIBRARIES SDL2::Core)
-    elseif(SDL2MAIN_LIBRARY)
-      # MinGW requires that the mingw32 library is specified before the
-      # libSDL2main.a static library when linking.
-      # The SDL2::MainInternal target is used internally to make sure that
-      # CMake respects this condition.
-      add_library(SDL2::MainInternal UNKNOWN IMPORTED)
-      set_property(TARGET SDL2::MainInternal PROPERTY
-                   IMPORTED_LOCATION "${SDL2MAIN_LIBRARY}")
-      set_property(TARGET SDL2::MainInternal PROPERTY
-                   INTERFACE_LINK_LIBRARIES SDL2::Core)
-
-      add_library(SDL2::Main INTERFACE IMPORTED)
-
-      if(MINGW)
-        # MinGW needs an additional link flag '-mwindows' and link to mingw32
-        set_property(TARGET SDL2::Main PROPERTY
-                     INTERFACE_LINK_LIBRARIES "mingw32" "-mwindows")
-      endif()
-
-      set_property(TARGET SDL2::Main APPEND PROPERTY
-                   INTERFACE_LINK_LIBRARIES SDL2::MainInternal)
-    endif()
-
-  endif()
-endif()

CMakeModules/GenerateSCMRev.cmake

@@ -18,13 +18,10 @@ if (DEFINED GIT_RELEASE)
   set(BUILD_VERSION "${GIT_TAG}")
   set(GIT_REFSPEC "${GIT_RELEASE}")
   set(IS_DEV_BUILD false)
-elseif(DEFINED GIT_COMMIT)
+else()
   string(SUBSTRING ${GIT_COMMIT} 0 10 BUILD_VERSION)
   set(BUILD_VERSION "${BUILD_VERSION}-${GIT_REFSPEC}")
   set(IS_DEV_BUILD true)
-else()
-  set(BUILD_VERSION "NoGitInfo")
-  set(IS_DEV_BUILD true)
 endif()
 
 set(GIT_DESC ${BUILD_VERSION})

CMakeModules/OpenOrbis.cmake

@@ -1,33 +0,0 @@
-# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-function(create_ps4_pkg project target content_id)
-    set(sce_sys_dir sce_sys)
-    set(sce_sys_param ${sce_sys_dir}/param.sfo)
-    add_custom_command(
-        OUTPUT "${target}.pkg"
-        COMMAND ${CMAKE_SYSROOT}/bin/create-fself -in=bin/${target} -out=${target}.oelf --eboot eboot.bin
-        COMMAND mkdir -p ${sce_sys_dir}
-        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_new ${sce_sys_param}
-        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} APP_TYPE --type Integer --maxsize 4 --value 1
-        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} APP_VER --type Utf8 --maxsize 8 --value 1.03
-        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} ATTRIBUTE --type Integer --maxsize 4 --value 0
-        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} CATEGORY --type Utf8 --maxsize 4 --value gd
-        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} CONTENT_ID --type Utf8 --maxsize 48 --value ${content_id}
-        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} DOWNLOAD_DATA_SIZE --type Integer --maxsize 4 --value 0
-        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} SYSTEM_VER --type Integer --maxsize 4 --value 0
-        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} TITLE --type Utf8 --maxsize 128 --value ${target}
-        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} TITLE_ID --type Utf8 --maxsize 12 --value BREW00090
-        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} VERSION --type Utf8 --maxsize 8 --value 1.03
-        COMMAND ${CMAKE_SYSROOT}/bin/create-gp4 -out ${target}.gp4 --content-id=${content_id} --files "eboot.bin ${sce_sys_param} sce_module/libc.prx sce_module/libSceFios2.prx"
-        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core pkg_build ${target}.gp4 .
-        VERBATIM
-        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-        DEPENDS ${project}
-    )
-    add_custom_target(${project}_pkg ALL DEPENDS "${target}.pkg")
-endfunction()
-
-if (NOT DEFINED ENV{OO_PS4_TOOLCHAIN})
-    set(ENV{OO_PS4_TOOLCHAIN} ${CMAKE_SYSROOT})
-endif ()

cpmfile.json

@@ -19,8 +19,7 @@
         "patches": [
             "0001-clang-cl.patch",
             "0002-use-marmasm.patch",
-            "0003-armasm-options.patch",
-            "0004-openorbis.patch"
+            "0003-armasm-options.patch"
         ]
     },
     "fmt": {

docs/Caveats.md

@@ -207,10 +207,3 @@ Install [Qt6 compatibility libraries](github.com/ANightly/qt6windows7) specifica
 The package install may randomly hang at times, in which case it has to be restarted. ALWAYS do a `sudo pkg update` or the chances of it hanging will be close to 90%. If "multiple" installs fail at once, try installing 1 by 1 the packages.
 
 When CMake invokes certain file syscalls - it may sometimes cause crashes or corruptions on the (kernel?) address space - so reboot the system if there is a "hang" in CMake.
-
-## PlayStation 4 (OpenOrbis cross compile)
-
-```sh
-export OO_PS4_TOOLCHAIN="$HOME/OpenOrbis/PS4Toolchain"
-export DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=1
-```

docs/user/Basics.md

@@ -26,7 +26,6 @@ Eden will store configuration files in the following directories:
 - **Android**: Data is stored internally.
 - **Linux, macOS, FreeBSD, Solaris, OpenBSD**: `$XDG_DATA_HOME`, `$XDG_CACHE_HOME`, `$XDG_CONFIG_HOME`.
 - **HaikuOS**: `/boot/home/config/settings/eden`
-- **PlayStation 4**: `/data/eden`
 
 If a `user` directory is present in the current working directory, that will override all global configuration directories and the emulator will use that instead.
 

externals/CMakeLists.txt

@@ -147,11 +147,7 @@ if (ENABLE_SDL2)
         AddJsonPackage(sdl2)
     endif()
 
-    if (PLATFORM_PS4)
-        set(SDL2_LIBRARY ${CMAKE_SYSROOT}/lib/libSDL2.a)
-        set(SDL2_INCLUDE_DIR ${CMAKE_SYSROOT}/include/SDL2)
-    endif()
-    find_package(SDL2 REQUIRED)
+    find_package(SDL2 2.26.4 REQUIRED)
 endif()
 
 set(BUILD_SHARED_LIBS OFF)

externals/cmake-modules/DetectPlatform.cmake

@@ -17,8 +17,6 @@
 
 if (${CMAKE_SYSTEM_NAME} STREQUAL "SunOS")
     set(PLATFORM_SUN ON)
-elseif (${CMAKE_SYSTEM_NAME} STREQUAL "OpenOrbis")
-    set(PLATFORM_PS4 ON)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
     set(PLATFORM_FREEBSD ON)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD")

externals/cpmfile.json

@@ -104,8 +104,7 @@
         "skip_updates": true,
         "patches": [
             "0001-aesni-fix.patch",
-            "0002-arm64-aes-fix.patch",
-            "0003-openorbis.patch"
+            "0002-arm64-aes-fix.patch"
         ]
     },
     "enet": {
@@ -114,10 +113,7 @@
         "hash": "a0d2fa8c957704dd49e00a726284ac5ca034b50b00d2b20a94fa1bbfbb80841467834bfdc84aa0ed0d6aab894608fd6c86c3b94eee46343f0e6d9c22e391dbf9",
         "version": "1.3",
         "git_version": "1.3.18",
-        "find_args": "MODULE",
-        "patches": [
-            "0001-openorbis.patch"
-        ]
+        "find_args": "MODULE"
     },
     "vulkan-utility-headers": {
         "package": "VulkanUtilityLibraries",
@@ -138,8 +134,7 @@
             "SPIRV_SKIP_EXECUTABLES ON"
         ],
         "patches": [
-            "0001-netbsd-fix.patch",
-            "0002-openorbis.patch"
+            "0001-netbsd-fix.patch"
         ]
     },
     "spirv-headers": {

externals/ffmpeg/CMakeLists.txt

@@ -13,106 +13,63 @@ set(FFmpeg_HWACCEL_FLAGS)
 set(FFmpeg_HWACCEL_INCLUDE_DIRS)
 set(FFmpeg_HWACCEL_LDFLAGS)
 
-if (NOT YUZU_USE_BUNDLED_FFMPEG)
-    set(FFmpeg_CROSS_COMPILE_FLAGS "")
-    if (ANDROID)
-        # TODO: Maybe use CMAKE_SYSROOT? and probably provide a toolchain file for android
-        # I mean isn't that the "proper" way anyways?
-        string(TOLOWER "${CMAKE_HOST_SYSTEM_NAME}" FFmpeg_HOST_SYSTEM_NAME)
-        set(TOOLCHAIN "${ANDROID_NDK}/toolchains/llvm/prebuilt/${FFmpeg_HOST_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}")
-        set(SYSROOT "${TOOLCHAIN}/sysroot")
-        set(FFmpeg_CPU "armv8-a")
-        list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
-            --enable-cross-compile
-            --arch=arm64
-            #--cpu=${FFmpeg_CPU}
-            --cross-prefix="${TOOLCHAIN}/bin/aarch64-linux-android-"
-            --sysroot="${SYSROOT}"
-            --target-os=android
-            --extra-ldflags="--ld-path=${TOOLCHAIN}/bin/ld.lld"
-            --extra-ldflags="-nostdlib"
-        )
-        set(FFmpeg_IS_CROSS_COMPILING TRUE)
-    # User attempts to do a FFmpeg cross compilation because...
-    # Here we just quickly test against host/system processors not matching
-    # TODO: Test for versions not matching as well?
-    elseif (NOT (CMAKE_HOST_SYSTEM_PROCESSOR MATCHES CMAKE_SYSTEM_PROCESSOR
-    AND CMAKE_HOST_SYSTEM_NAME MATCHES CMAKE_SYSTEM_NAME))
-        string(TOLOWER "${CMAKE_SYSTEM_NAME}" FFmpeg_SYSTEM_NAME)
-        if (FFmpeg_SYSTEM_NAME STREQUAL "openorbis")
-            set(FFmpeg_SYSTEM_NAME "freebsd") # Emulates FBSD :)
-        endif()
-        # TODO: Can we really do better? Auto-detection? Something clever?
-        list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
-            --enable-cross-compile
-            --arch="${CMAKE_SYSTEM_PROCESSOR}"
-            --target-os="${FFmpeg_SYSTEM_NAME}"
-            --sysroot="${CMAKE_SYSROOT}"
-        )
-        if (DEFINED FFmpeg_CROSS_PREFIX)
-            list(APPEND FFmpeg_CROSS_COMPILE_FLAGS --cross-prefix="${FFmpeg_CROSS_PREFIX}")
-        else()
-            message(WARNING "Please set FFmpeg_CROSS_PREFIX to your cross toolchain prefix, for example: \${CMAKE_STAGING_PREFIX}/bin/${CMAKE_SYSTEM_PROCESSOR}-${CMAKE_SYSTEM_NAME}-")
-        endif()
-        set(FFmpeg_IS_CROSS_COMPILING TRUE)
-    endif()
-endif()
-
-if (PLATFORM_PS4)
-    list(APPEND FFmpeg_HWACCEL_FLAGS
-        --disable-vaapi
-    )
-elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING)
+if (UNIX AND NOT ANDROID)
     find_package(PkgConfig REQUIRED)
-    pkg_check_modules(LIBVA libva)
-    pkg_check_modules(CUDA cuda)
-    pkg_check_modules(FFNVCODEC ffnvcodec)
-    pkg_check_modules(VDPAU vdpau)
+    if (NOT ANDROID)
+        pkg_check_modules(LIBVA libva)
+        pkg_check_modules(CUDA cuda)
+        pkg_check_modules(FFNVCODEC ffnvcodec)
+        pkg_check_modules(VDPAU vdpau)
+    endif()
 
-    find_package(X11)
-    if(X11_FOUND)
-        if (NOT APPLE)
-            # In Solaris needs explicit linking for ffmpeg which links to /lib/amd64/libX11.so
-            if(PLATFORM_SUN)
+    if (NOT APPLE)
+        # In Solaris needs explicit linking for ffmpeg which links to /lib/amd64/libX11.so
+        if(PLATFORM_SUN)
+            find_library(LIBDRM_LIB libdrm PATHS /usr/lib/64 /usr/lib/amd64 /usr/lib)
+            if(LIBDRM_LIB)
                 list(APPEND FFmpeg_HWACCEL_LIBRARIES
                     X11
-                    "${CMAKE_SYSROOT}/usr/lib/xorg/amd64/libdrm.so")
+                    "${LIBDRM_LIB}")
+                message(STATUS "Found libdrm at: ${LIBDRM_LIB}")
             else()
-                pkg_check_modules(LIBDRM libdrm REQUIRED)
-                list(APPEND FFmpeg_HWACCEL_LIBRARIES
-                    ${LIBDRM_LIBRARIES})
-                list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-                    ${LIBDRM_INCLUDE_DIRS})
+                message(WARNING "libdrm not found, disabling libdrm support")
+                list(APPEND FFmpeg_HWACCEL_FLAGS
+                    --disable-libdrm)
             endif()
+        else()
+            pkg_check_modules(LIBDRM libdrm REQUIRED)
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES
+                ${LIBDRM_LIBRARIES})
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
+                ${LIBDRM_INCLUDE_DIRS})
             list(APPEND FFmpeg_HWACCEL_FLAGS
                 --enable-libdrm)
         endif()
-        if(LIBVA_FOUND)
-            pkg_check_modules(LIBVA-DRM libva-drm REQUIRED)
-            pkg_check_modules(LIBVA-X11 libva-x11 REQUIRED)
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES
-                ${X11_LIBRARIES}
-                ${LIBVA-DRM_LIBRARIES}
-                ${LIBVA-X11_LIBRARIES}
-                ${LIBVA_LIBRARIES})
-            list(APPEND FFmpeg_HWACCEL_FLAGS
-                --enable-hwaccel=h264_vaapi
-                --enable-hwaccel=vp8_vaapi
-                --enable-hwaccel=vp9_vaapi)
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-                ${X11_INCLUDE_DIRS}
-                ${LIBVA-DRM_INCLUDE_DIRS}
-                ${LIBVA-X11_INCLUDE_DIRS}
-                ${LIBVA_INCLUDE_DIRS}
-            )
-            message(STATUS "ffmpeg: va-api libraries version ${LIBVA_VERSION} found")
-        else()
-            list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
-            message(WARNING "ffmpeg: libva-dev not found, disabling Video Acceleration API (VA-API)...")
-        endif()
+    endif()
+
+    if(LIBVA_FOUND)
+        find_package(X11 REQUIRED)
+        pkg_check_modules(LIBVA-DRM libva-drm REQUIRED)
+        pkg_check_modules(LIBVA-X11 libva-x11 REQUIRED)
+        list(APPEND FFmpeg_HWACCEL_LIBRARIES
+            ${X11_LIBRARIES}
+            ${LIBVA-DRM_LIBRARIES}
+            ${LIBVA-X11_LIBRARIES}
+            ${LIBVA_LIBRARIES})
+        list(APPEND FFmpeg_HWACCEL_FLAGS
+            --enable-hwaccel=h264_vaapi
+            --enable-hwaccel=vp8_vaapi
+            --enable-hwaccel=vp9_vaapi)
+        list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
+            ${X11_INCLUDE_DIRS}
+            ${LIBVA-DRM_INCLUDE_DIRS}
+            ${LIBVA-X11_INCLUDE_DIRS}
+            ${LIBVA_INCLUDE_DIRS}
+        )
+        message(STATUS "ffmpeg: va-api libraries version ${LIBVA_VERSION} found")
     else()
         list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
-        message(WARNING "ffmpeg: X11 libraries not found, disabling VA-API...")
+        message(WARNING "ffmpeg: libva-dev not found, disabling Video Acceleration API (VA-API)...")
     endif()
 
     if (FFNVCODEC_FOUND)
@@ -156,23 +113,6 @@ elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING)
     endif()
 endif()
 
-if (PLATFORM_PS4)
-    list(APPEND FFmpeg_CROSS_COMPILE_LIBS
-        -lc
-        -lkernel
-        -lSceUserService
-        -lSceSysmodule
-        -lSceNet
-        -lSceLibcInternal
-    )
-    list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
-        --disable-pthreads
-        --extra-cflags=${CMAKE_SYSROOT}/usr/include
-        --extra-cxxflags=${CMAKE_SYSROOT}/usr/include
-        --extra-libs="${FFmpeg_CROSS_COMPILE_LIBS}"
-    )
-endif()
-
 if (YUZU_USE_BUNDLED_FFMPEG)
     AddJsonPackage(ffmpeg-ci)
 
@@ -243,6 +183,24 @@ else()
 
     find_program(BASH_PROGRAM bash REQUIRED)
 
+    set(FFmpeg_CROSS_COMPILE_FLAGS "")
+    if (ANDROID)
+        string(TOLOWER "${CMAKE_HOST_SYSTEM_NAME}" FFmpeg_HOST_SYSTEM_NAME)
+        set(TOOLCHAIN "${ANDROID_NDK}/toolchains/llvm/prebuilt/${FFmpeg_HOST_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}")
+        set(SYSROOT "${TOOLCHAIN}/sysroot")
+        set(FFmpeg_CPU "armv8-a")
+        list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
+            --arch=arm64
+            #--cpu=${FFmpeg_CPU}
+            --enable-cross-compile
+            --cross-prefix=${TOOLCHAIN}/bin/aarch64-linux-android-
+            --sysroot=${SYSROOT}
+            --target-os=android
+            --extra-ldflags="--ld-path=${TOOLCHAIN}/bin/ld.lld"
+            --extra-ldflags="-nostdlib"
+        )
+    endif()
+
     # `configure` parameters builds only exactly what yuzu needs from FFmpeg
     # `--disable-vdpau` is needed to avoid linking issues
     set(FFmpeg_CC ${CMAKE_C_COMPILER_LAUNCHER}  ${CMAKE_C_COMPILER})
@@ -265,12 +223,8 @@ else()
                 --enable-decoder=vp9
                 --enable-filter=yadif,scale
                 --enable-pic
-                --cc=${FFmpeg_CC}
-                --cxx=${FFmpeg_CXX}
-                --ld=${CMAKE_LINKER}
-                --extra-cflags=${CMAKE_C_FLAGS}
-                --extra-cxxflags=${CMAKE_CXX_FLAGS}
-                --extra-ldflags=${CMAKE_C_LINK_FLAGS}
+                --cc="${FFmpeg_CC}"
+                --cxx="${FFmpeg_CXX}"
                 ${FFmpeg_HWACCEL_FLAGS}
                 ${FFmpeg_CROSS_COMPILE_FLAGS}
         WORKING_DIRECTORY
@@ -302,7 +256,7 @@ else()
         OUTPUT
             ${FFmpeg_BUILD_LIBRARIES}
         COMMAND
-            gmake ${FFmpeg_MAKE_ARGS}
+            make ${FFmpeg_MAKE_ARGS}
         WORKING_DIRECTORY
             ${FFmpeg_BUILD_DIR}
     )

src/audio_core/CMakeLists.txt

@@ -251,8 +251,8 @@ if (ENABLE_SDL2)
         sink/sdl2_sink.cpp
         sink/sdl2_sink.h
     )
-    target_include_directories(audio_core PRIVATE ${CMAKE_SYSROOT}/include/SDL2)
-    target_link_libraries(audio_core PRIVATE SDL2)
+
+    target_link_libraries(audio_core PRIVATE SDL2::SDL2)
     target_compile_definitions(audio_core PRIVATE HAVE_SDL2)
 endif()
 

src/common/fs/fs.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -174,14 +171,11 @@ bool CreateDir(const fs::path& path) {
         return false;
     }
 
-    // TODO: Maybe this is what causes death?
-#ifndef __OPENORBIS__
     if (!Exists(path.parent_path())) {
         LOG_ERROR(Common_Filesystem, "Parent directory of path={} does not exist",
                   PathToUTF8String(path));
         return false;
     }
-#endif
 
     if (IsDir(path)) {
         LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} exists and is a directory",

src/common/fs/path_util.cpp

@@ -130,10 +130,6 @@ public:
         ASSERT(!eden_path.empty());
         eden_path_cache = eden_path / CACHE_DIR;
         eden_path_config = eden_path / CONFIG_DIR;
-#elif defined(__OPENORBIS__)
-        eden_path = "/data/eden";
-        eden_path_cache = eden_path / CACHE_DIR;
-        eden_path_config = eden_path / CONFIG_DIR;
 #else
         eden_path = GetCurrentDir() / PORTABLE_DIR;
         if (!Exists(eden_path) || !IsDir(eden_path)) {

src/common/host_memory.cpp

@@ -30,21 +30,19 @@
 #include <sys/random.h>
 #include <mach/vm_map.h>
 #include <mach/mach.h>
-#elif defined(__OPENORBIS__)
-#include <orbis/libkernel.h>
 #endif
 
 // FreeBSD
 #ifndef MAP_NORESERVE
-#   define MAP_NORESERVE 0
+#define MAP_NORESERVE 0
 #endif
 // Solaris 11 and illumos
 #ifndef MAP_ALIGNED_SUPER
-#   define MAP_ALIGNED_SUPER 0
+#define MAP_ALIGNED_SUPER 0
 #endif
 // macOS
 #ifndef MAP_ANONYMOUS
-#   define MAP_ANONYMOUS MAP_ANON
+#define MAP_ANONYMOUS MAP_ANON
 #endif
 
 #endif // ^^^ POSIX ^^^
@@ -70,8 +68,8 @@ static int memfd_create(const char* name, unsigned int flags) {
 
 namespace Common {
 
-[[maybe_unused]] constexpr size_t PageAlignment = 0x1000;
-[[maybe_unused]] constexpr size_t HugePageSize = 0x200000;
+constexpr size_t PageAlignment = 0x1000;
+constexpr size_t HugePageSize = 0x200000;
 
 #ifdef _WIN32
 
@@ -440,15 +438,13 @@ static void* ChooseVirtualBase(size_t virtual_size) {
 
 #else
 
-static void* ChooseVirtualBase(size_t size) {
+static void* ChooseVirtualBase(size_t virtual_size) {
 #if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__) || defined(__managarm__) || defined(__AIX__)
-    void* virtual_base = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_ALIGNED_SUPER, -1, 0);
+    void* virtual_base = mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_ALIGNED_SUPER, -1, 0);
     if (virtual_base != MAP_FAILED)
         return virtual_base;
-    return mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
-#else
-    return mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
 #endif
+    return mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
 }
 
 #endif
@@ -504,12 +500,9 @@ class HostMemory::Impl {
 public:
     explicit Impl(size_t backing_size_, size_t virtual_size_)
         : backing_size{backing_size_}, virtual_size{virtual_size_} {
-#ifdef __OPENORBIS__
-
-#else
         long page_size = sysconf(_SC_PAGESIZE);
-        ASSERT_MSG(page_size == 0x1000, "page size {:#x} is incompatible with 4K paging", page_size);
-#endif
+        ASSERT_MSG(page_size == 0x1000, "page size {:#x} is incompatible with 4K paging",
+                   page_size);
         // Backing memory initialization
 #if defined(__sun__) || defined(__HAIKU__) || defined(__NetBSD__) || defined(__DragonFly__)
         fd = shm_open_anon(O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW, 0600);
@@ -699,25 +692,31 @@ private:
 
 #endif // ^^^ POSIX ^^^
 
-HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_) : backing_size(backing_size_), virtual_size(virtual_size_) {
-#ifdef __OPENORBIS__
-    Common::InitSwap();
-    LOG_WARNING(HW_Memory, "Platform doesn't support fastmem");
-    fallback_buffer.emplace(backing_size);
-    backing_base = fallback_buffer->data();
-    virtual_base = nullptr;
-#else
-    // Try to allocate a fastmem arena.
-    // The implementation will fail with std::bad_alloc on errors.
-    impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize);
-    backing_base = impl->backing_base;
-    virtual_base = impl->virtual_base;
-    if (virtual_base) {
-        // Ensure the virtual base is aligned to the L2 block size.
-        virtual_base = reinterpret_cast<u8*>(Common::AlignUp(uintptr_t(virtual_base), HugePageSize));
-        virtual_base_offset = virtual_base - impl->virtual_base;
+HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
+    : backing_size(backing_size_), virtual_size(virtual_size_) {
+    try {
+        // Try to allocate a fastmem arena.
+        // The implementation will fail with std::bad_alloc on errors.
+        impl =
+            std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment),
+                                               AlignUp(virtual_size, PageAlignment) + HugePageSize);
+        backing_base = impl->backing_base;
+        virtual_base = impl->virtual_base;
+
+        if (virtual_base) {
+            // Ensure the virtual base is aligned to the L2 block size.
+            virtual_base = reinterpret_cast<u8*>(
+                Common::AlignUp(reinterpret_cast<uintptr_t>(virtual_base), HugePageSize));
+            virtual_base_offset = virtual_base - impl->virtual_base;
+        }
+
+    } catch (const std::bad_alloc&) {
+        LOG_CRITICAL(HW_Memory,
+                     "Fastmem unavailable, falling back to VirtualBuffer for memory allocation");
+        fallback_buffer = std::make_unique<Common::VirtualBuffer<u8>>(backing_size);
+        backing_base = fallback_buffer->data();
+        virtual_base = nullptr;
     }
-#endif
 }
 
 HostMemory::~HostMemory() = default;

src/common/host_memory.h

@@ -1,13 +1,9 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 
 #include <memory>
-#include <optional>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/virtual_buffer.h"
@@ -85,7 +81,7 @@ private:
     size_t virtual_base_offset{};
 
     // Fallback if fastmem is not supported on this platform
-    std::optional<Common::VirtualBuffer<u8>> fallback_buffer;
+    std::unique_ptr<Common::VirtualBuffer<u8>> fallback_buffer;
 };
 
 } // namespace Common

src/common/memory_detect.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -11,7 +8,7 @@
 // clang-format on
 #else
 #include <sys/types.h>
-#if defined(__APPLE__) || (defined(__FreeBSD__) && !defined(__OPENORBIS__))
+#if defined(__APPLE__) || defined(__FreeBSD__)
 #include <sys/sysctl.h>
 #elif defined(__linux__)
 #include <sys/sysinfo.h>
@@ -46,8 +43,6 @@ static MemoryInfo Detect() {
     sysctlbyname("vm.swapusage", &vmusage, &sizeof_vmusage, nullptr, 0);
     mem_info.TotalPhysicalMemory = ramsize;
     mem_info.TotalSwapMemory = vmusage.xsu_total;
-#elif defined(__OPENORBIS__)
-    mem_info.TotalPhysicalMemory = mem_info.TotalSwapMemory = 0;
 #elif defined(__FreeBSD__)
     u_long physmem, swap_total;
     std::size_t sizeof_u_long = sizeof(u_long);

src/common/settings.h

@@ -196,14 +196,7 @@ struct Values {
                                              linkage, false, "dump_audio_commands", Category::Audio, Specialization::Default, false};
 
     // Core
-    SwitchableSetting<bool> use_multi_core{linkage,
-#ifdef __OPENORBIS__
-        // Re-enable once proper TLS support is added
-        false,
-#else
-        true,
-#endif
-        "use_multi_core", Category::Core};
+    SwitchableSetting<bool> use_multi_core{linkage, true, "use_multi_core", Category::Core};
     SwitchableSetting<MemoryLayout, true> memory_layout_mode{linkage,
                                                              MemoryLayout::Memory_4Gb,
                                                              "memory_layout_mode",
@@ -325,14 +318,14 @@ struct Values {
 
     // Renderer
     SwitchableSetting<RendererBackend, true> renderer_backend{linkage,
-#if defined(__sun__) || defined(__managarm__) || defined(__OPENORBIS__)
+#if defined(__sun__) || defined(__managarm__)
                                                               RendererBackend::OpenGL,
 #else
                                                               RendererBackend::Vulkan,
 #endif
                                                               "backend", Category::Renderer};
     SwitchableSetting<ShaderBackend, true> shader_backend{linkage,
-#if defined(__sun__) || defined(__managarm__) || defined(__OPENORBIS__)
+#if defined(__sun__) || defined(__managarm__)
                                                           ShaderBackend::Glsl,
 #else
                                                           ShaderBackend::SpirV,

src/common/virtual_buffer.cpp

@@ -10,147 +10,30 @@
 #include <sys/mman.h>
 #endif
 
-#ifdef __OPENORBIS__
-#include <ranges>
-#include <csignal>
-#include <boost/container/static_vector.hpp>
-#include <orbis/SystemService.h>
-typedef void (*SceKernelExceptionHandler)(int32_t, void*);
-extern "C" int32_t sceKernelInstallExceptionHandler(int32_t signum, SceKernelExceptionHandler handler);
-#endif
-
 #include "common/assert.h"
 #include "common/virtual_buffer.h"
-#include "common/logging/log.h"
-
-// PlayStation 4
-// Flag needs to be undef-ed on non PS4 since it has different semantics
-// on some platforms.
-#ifdef __OPENORBIS__
-#   ifndef MAP_SYSTEM
-#       define MAP_SYSTEM 0x2000
-#   endif
-#   ifndef MAP_VOID
-#       define MAP_VOID 0x100
-#   endif
-// sigaction(2) has a motherfucking bug on musl where the thing isnt even properly prefixed
-#   undef sa_sigaction
-#   define sa_sigaction __sa_handler.__sa_sigaction
-#endif
 
 namespace Common {
 
-#ifdef __OPENORBIS__
-
-namespace Orbis {
-struct Ucontext {
-    struct Sigset {
-        u64 bits[2];
-    } uc_sigmask;
-    int field1_0x10[12];
-    struct Mcontext {
-        u64 mc_onstack;
-        u64 mc_rdi;
-        u64 mc_rsi;
-        u64 mc_rdx;
-        u64 mc_rcx;
-        u64 mc_r8;
-        u64 mc_r9;
-        u64 mc_rax;
-        u64 mc_rbx;
-        u64 mc_rbp;
-        u64 mc_r10;
-        u64 mc_r11;
-        u64 mc_r12;
-        u64 mc_r13;
-        u64 mc_r14;
-        u64 mc_r15;
-        int mc_trapno;
-        u16 mc_fs;
-        u16 mc_gs;
-        u64 mc_addr;
-        int mc_flags;
-        u16 mc_es;
-        u16 mc_ds;
-        u64 mc_err;
-        u64 mc_rip;
-        u64 mc_cs;
-        u64 mc_rflags;
-        u64 mc_rsp;
-        u64 mc_ss;
-        u64 mc_len;
-        u64 mc_fpformat;
-        u64 mc_ownedfp;
-        u64 mc_lbrfrom;
-        u64 mc_lbrto;
-        u64 mc_aux1;
-        u64 mc_aux2;
-        u64 mc_fpstate[104];
-        u64 mc_fsbase;
-        u64 mc_gsbase;
-        u64 mc_spare[6];
-    } uc_mcontext;
-    struct Ucontext* uc_link;
-    struct ExStack {
-        void* ss_sp;
-        std::size_t ss_size;
-        int ss_flags;
-        int _align;
-    } uc_stack;
-    int uc_flags;
-    int __spare[4];
-    int field7_0x4f4[3];
-};
-}
-
-static boost::container::static_vector<std::pair<void*, size_t>, 16> swap_regions;
-extern "C" int sceKernelRemoveExceptionHandler(s32 sig_num);
-static void SwapHandler(int sig, void* raw_context) {
-    auto& mctx = ((Orbis::Ucontext*)raw_context)->uc_mcontext;
-    if (std::ranges::find_if(swap_regions, [addr = mctx.mc_addr](auto const& e) {
-        return uintptr_t(addr) >= uintptr_t(e.first) && uintptr_t(addr) < uintptr_t(e.first) + e.second;
-    }) != swap_regions.end()) {
-        size_t const page_size = 4096;
-        size_t const page_mask = ~0xfff;
-        // should replace the existing mapping... ugh
-        void* aligned_addr = reinterpret_cast<void*>(uintptr_t(mctx.mc_addr) & page_mask);
-        void* res = mmap(aligned_addr, page_size, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
-        ASSERT(res != MAP_FAILED);
-    } else {
-        LOG_ERROR(HW_Memory, "fault in addr {:#x} at {:#x}", mctx.mc_addr, mctx.mc_rip); // print caller address
-        sceKernelRemoveExceptionHandler(SIGSEGV); // to not catch the next signal
-    }
-}
-void InitSwap() noexcept {
-    sceKernelInstallExceptionHandler(SIGSEGV, &SwapHandler);
-}
-#else
-void InitSwap() noexcept {}
-#endif
-
 void* AllocateMemoryPages(std::size_t size) noexcept {
 #ifdef _WIN32
-    void* addr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE);
-    ASSERT(addr != nullptr);
-#elif defined(__OPENORBIS__)
-    void* addr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_VOID | MAP_PRIVATE, -1, 0);
-    ASSERT(addr != MAP_FAILED);
-    swap_regions.emplace_back(addr, size);
+    void* base = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE);
 #else
-    void* addr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
-    ASSERT(addr != MAP_FAILED);
+    void* base = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
+    if (base == MAP_FAILED)
+        base = nullptr;
 #endif
-    return addr;
+    ASSERT(base);
+    return base;
 }
 
-void FreeMemoryPages(void* addr, [[maybe_unused]] std::size_t size) noexcept {
-    if (!addr)
+void FreeMemoryPages(void* base, [[maybe_unused]] std::size_t size) noexcept {
+    if (!base)
         return;
 #ifdef _WIN32
-    VirtualFree(addr, 0, MEM_RELEASE);
+    ASSERT(VirtualFree(base, 0, MEM_RELEASE));
 #else
-    int rc = munmap(addr, size);
-    ASSERT(rc == 0);
+    ASSERT(munmap(base, size) == 0);
 #endif
 }
 

src/common/virtual_buffer.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -12,7 +9,6 @@ namespace Common {
 
 void* AllocateMemoryPages(std::size_t size) noexcept;
 void FreeMemoryPages(void* base, std::size_t size) noexcept;
-void InitSwap() noexcept;
 
 template <typename T>
 class VirtualBuffer final {
@@ -36,10 +32,9 @@ public:
     VirtualBuffer(const VirtualBuffer&) = delete;
     VirtualBuffer& operator=(const VirtualBuffer&) = delete;
 
-    VirtualBuffer(VirtualBuffer&& other) noexcept {
-        alloc_size = std::exchange(other.alloc_size, 0);
-        base_ptr = std::exchange(other.base_ptr, nullptr);
-    }
+    VirtualBuffer(VirtualBuffer&& other) noexcept
+        : alloc_size{std::exchange(other.alloc_size, 0)}, base_ptr{std::exchange(other.base_ptr),
+                                                                   nullptr} {}
 
     VirtualBuffer& operator=(VirtualBuffer&& other) noexcept {
         alloc_size = std::exchange(other.alloc_size, 0);

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -295,7 +295,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ArmDynarmic32::MakeJit(Common::PageTable* pa
     // Curated optimizations
     case Settings::CpuAccuracy::Auto:
         config.unsafe_optimizations = true;
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__) || defined(__DragonFly__) || defined(__NetBSD__) || defined(__OPENORBIS__)
+#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__) || defined(__DragonFly__) || defined(__NetBSD__)
         config.fastmem_pointer = std::nullopt;
         config.fastmem_exclusive_access = false;
 #endif

src/core/device_memory.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -29,22 +26,27 @@ public:
 
     template <typename T>
     Common::PhysicalAddress GetPhysicalAddr(const T* ptr) const {
-        return (uintptr_t(ptr) - uintptr_t(buffer.BackingBasePointer())) + DramMemoryMap::Base;
+        return (reinterpret_cast<uintptr_t>(ptr) -
+                reinterpret_cast<uintptr_t>(buffer.BackingBasePointer())) +
+               DramMemoryMap::Base;
     }
 
     template <typename T>
     PAddr GetRawPhysicalAddr(const T* ptr) const {
-        return PAddr(uintptr_t(ptr) - uintptr_t(buffer.BackingBasePointer()));
+        return static_cast<PAddr>(reinterpret_cast<uintptr_t>(ptr) -
+                                  reinterpret_cast<uintptr_t>(buffer.BackingBasePointer()));
     }
 
     template <typename T>
     T* GetPointer(Common::PhysicalAddress addr) {
-        return reinterpret_cast<T*>(buffer.BackingBasePointer() + (GetInteger(addr) - DramMemoryMap::Base));
+        return reinterpret_cast<T*>(buffer.BackingBasePointer() +
+                                    (GetInteger(addr) - DramMemoryMap::Base));
     }
 
     template <typename T>
     const T* GetPointer(Common::PhysicalAddress addr) const {
-        return reinterpret_cast<T*>(buffer.BackingBasePointer() + (GetInteger(addr) - DramMemoryMap::Base));
+        return reinterpret_cast<T*>(buffer.BackingBasePointer() +
+                                    (GetInteger(addr) - DramMemoryMap::Base));
     }
 
     template <typename T>

src/core/device_memory_manager.inc

@@ -161,7 +161,7 @@ struct DeviceMemoryManagerAllocator {
 
 template <typename Traits>
 DeviceMemoryManager<Traits>::DeviceMemoryManager(const DeviceMemory& device_memory_)
-    : physical_base{uintptr_t(device_memory_.buffer.BackingBasePointer())},
+    : physical_base{reinterpret_cast<const uintptr_t>(device_memory_.buffer.BackingBasePointer())},
       device_inter{nullptr}, compressed_physical_ptr(device_as_size >> Memory::YUZU_PAGEBITS),
       compressed_device_addr(1ULL << ((Settings::values.memory_layout_mode.GetValue() ==
                                                Settings::MemoryLayout::Memory_4Gb

src/core/hle/kernel/kernel.cpp

@@ -69,9 +69,7 @@ struct KernelCore::Impl {
         global_object_list_container = std::make_unique<KAutoObjectWithListContainer>(kernel);
         global_scheduler_context = std::make_unique<Kernel::GlobalSchedulerContext>(kernel);
 
-#ifndef __OPENORBIS__
         is_phantom_mode_for_singlecore = false;
-#endif
 
         // Derive the initial memory layout from the emulated board
         Init::InitializeSlabResourceCounts(kernel);
@@ -358,11 +356,7 @@ struct KernelCore::Impl {
         application_process->Open();
     }
 
-#ifdef __OPENORBIS__
-    static inline u8 host_thread_id = UINT8_MAX;
-#else
     static inline thread_local u8 host_thread_id = UINT8_MAX;
-#endif
 
     /// Sets the host thread ID for the caller.
     u32 SetHostThreadId(std::size_t core_id) {
@@ -386,14 +380,8 @@ struct KernelCore::Impl {
             ASSERT(KThread::InitializeDummyThread(thread, nullptr).IsSuccess());
             return thread;
         }};
-#ifdef __OPENORBIS__
-        // No proper TLS yet
-        static KThread raw_thread{system.Kernel()};
-        static KThread* thread = existing_thread ? existing_thread : initialize(&raw_thread);
-#else
         thread_local KThread raw_thread{system.Kernel()};
         thread_local KThread* thread = existing_thread ? existing_thread : initialize(&raw_thread);
-#endif
         return thread;
     }
 
@@ -419,33 +407,22 @@ struct KernelCore::Impl {
         return this_id;
     }
 
-#ifdef __OPENORBIS__
-    bool IsPhantomModeForSingleCore() const {
-        return true;
-    }
-    void SetIsPhantomModeForSingleCore(bool value) {}
-#else
-    // Forces singlecore
     static inline thread_local bool is_phantom_mode_for_singlecore{false};
+
     bool IsPhantomModeForSingleCore() const {
         return is_phantom_mode_for_singlecore;
     }
+
     void SetIsPhantomModeForSingleCore(bool value) {
         ASSERT(!is_multicore);
         is_phantom_mode_for_singlecore = value;
     }
-#endif
 
     bool IsShuttingDown() const {
         return is_shutting_down.load(std::memory_order_relaxed);
     }
 
-#ifdef __OPENORBIS__
-    // PS4 doesn't have proper TLS handling
-    static inline KThread* current_thread{nullptr};
-#else
     static inline thread_local KThread* current_thread{nullptr};
-#endif
 
     KThread* GetCurrentEmuThread() {
         if (!current_thread) {

src/dynarmic/src/dynarmic/backend/exception_handler_posix.cpp

@@ -59,16 +59,12 @@ public:
         signal_stack_size = std::max<size_t>(SIGSTKSZ, 2 * 1024 * 1024);
         signal_stack_memory = mmap(nullptr, signal_stack_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 
-#ifdef __OPENORBIS__
-        fmt::print(stderr, "no fastmem on PS4\n");
-        supports_fast_mem = false;
-#else
         stack_t signal_stack{};
         signal_stack.ss_sp = signal_stack_memory;
         signal_stack.ss_size = signal_stack_size;
         signal_stack.ss_flags = 0;
         if (sigaltstack(&signal_stack, nullptr) != 0) {
-            fmt::print(stderr, "POSIX SigHandler: init failure at sigaltstack\n");
+            fmt::print(stderr, "dynarmic: POSIX SigHandler: init failure at sigaltstack\n");
             supports_fast_mem = false;
             return;
         }
@@ -79,17 +75,16 @@ public:
         sa.sa_flags = SA_SIGINFO | SA_ONSTACK | SA_RESTART;
         sigemptyset(&sa.sa_mask);
         if (sigaction(SIGSEGV, &sa, &old_sa_segv) != 0) {
-            fmt::print(stderr, "POSIX SigHandler: could not set SIGSEGV handler\n");
+            fmt::print(stderr, "dynarmic: POSIX SigHandler: could not set SIGSEGV handler\n");
             supports_fast_mem = false;
             return;
         }
-#   ifdef __APPLE__
+#ifdef __APPLE__
         if (sigaction(SIGBUS, &sa, &old_sa_bus) != 0) {
-            fmt::print(stderr, "POSIX SigHandler: could not set SIGBUS handler\n");
+            fmt::print(stderr, "dynarmic: POSIX SigHandler: could not set SIGBUS handler\n");
             supports_fast_mem = false;
             return;
         }
-#   endif
 #endif
     }
 
@@ -150,9 +145,6 @@ void SigHandler::SigAction(int sig, siginfo_t* info, void* raw_context) {
 #    error "Invalid architecture"
 #endif
 
-#ifdef __OPENORBIS__
-    // No fastmem
-#else
     struct sigaction* retry_sa = sig == SIGSEGV ? &sig_handler->old_sa_segv : &sig_handler->old_sa_bus;
     if (retry_sa->sa_flags & SA_SIGINFO) {
         retry_sa->sa_sigaction(sig, info, raw_context);
@@ -166,7 +158,6 @@ void SigHandler::SigAction(int sig, siginfo_t* info, void* raw_context) {
         return;
     }
     retry_sa->sa_handler(sig);
-#endif
 }
 
 }  // anonymous namespace

src/dynarmic/src/dynarmic/common/context.h

@@ -60,7 +60,7 @@
 #    elif defined(__linux__)
 #        define CTX_RIP (mctx.gregs[REG_RIP])
 #        define CTX_RSP (mctx.gregs[REG_RSP])
-#    elif defined(__FreeBSD__) || defined(__DragonFly__)
+#    elif defined(__FreeBSD__)
 #        define CTX_RIP (mctx.mc_rip)
 #        define CTX_RSP (mctx.mc_rsp)
 #    elif defined(__NetBSD__)
@@ -72,9 +72,9 @@
 #    elif defined(__sun__)
 #        define CTX_RIP (mctx.gregs[REG_RIP])
 #        define CTX_RSP (mctx.gregs[REG_RSP])
-#    elif defined(__OPENORBIS__)
-#        define CTX_RIP (mctx.gregs[REG_RIP])
-#        define CTX_RSP (mctx.gregs[REG_RSP])
+#    elif defined(__DragonFly__)
+#        define CTX_RIP (mctx.mc_rip)
+#        define CTX_RSP (mctx.mc_rsp)
 #    else
 #        error "Unknown platform"
 #    endif
@@ -97,7 +97,7 @@
 #        define CTX_Q(i) (fpctx->vregs[i])
 #        define CTX_FPSR (fpctx->fpsr)
 #        define CTX_FPCR (fpctx->fpcr)
-#    elif defined(__FreeBSD__) || defined(__DragonFly__)
+#    elif defined(__FreeBSD__)
 #        define CTX_PC (mctx.mc_gpregs.gp_elr)
 #        define CTX_SP (mctx.mc_gpregs.gp_sp)
 #        define CTX_LR (mctx.mc_gpregs.gp_lr)

src/input_common/CMakeLists.txt

@@ -75,8 +75,7 @@ if (ENABLE_SDL2)
         helpers/joycon_protocol/rumble.cpp
         helpers/joycon_protocol/rumble.h
     )
-    target_include_directories(input_common PRIVATE ${CMAKE_SYSROOT}/include/SDL2)
-    target_link_libraries(input_common PRIVATE SDL2)
+    target_link_libraries(input_common PRIVATE SDL2::SDL2)
     target_compile_definitions(input_common PRIVATE HAVE_SDL2)
 endif()
 

src/input_common/drivers/joycon.cpp

@@ -23,14 +23,12 @@ Joycons::Joycons(const std::string& input_engine_) : InputEngine(input_engine_)
         return;
     }
     LOG_INFO(Input, "Joycon driver Initialization started");
-#if SDL_VERSION_ATLEAST(2, 26, 4)
-    int const res = SDL_hid_init();
-    if (res == 0) {
+    const int init_res = SDL_hid_init();
+    if (init_res == 0) {
         Setup();
     } else {
-        LOG_ERROR(Input, "Hidapi could not be initialized. failed with error = {}", res);
+        LOG_ERROR(Input, "Hidapi could not be initialized. failed with error = {}", init_res);
     }
-#endif
 }
 
 Joycons::~Joycons() {
@@ -57,9 +55,7 @@ void Joycons::Reset() {
         }
         device->Stop();
     }
-#if SDL_VERSION_ATLEAST(2, 26, 4)
     SDL_hid_exit();
-#endif
 }
 
 void Joycons::Setup() {
@@ -84,9 +80,9 @@ void Joycons::Setup() {
 }
 
 void Joycons::ScanThread(std::stop_token stop_token) {
-#if SDL_VERSION_ATLEAST(2, 26, 4)
     constexpr u16 nintendo_vendor_id = 0x057e;
     Common::SetCurrentThreadName("JoyconScanThread");
+
     do {
         SDL_hid_device_info* devs = SDL_hid_enumerate(nintendo_vendor_id, 0x0);
         SDL_hid_device_info* cur_dev = devs;
@@ -102,7 +98,6 @@ void Joycons::ScanThread(std::stop_token stop_token) {
 
         SDL_hid_free_enumeration(devs);
     } while (Common::StoppableTimedWait(stop_token, std::chrono::seconds{5}));
-#endif
 }
 
 bool Joycons::IsDeviceNew(SDL_hid_device_info* device_info) const {

src/input_common/drivers/joycon.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -9,14 +6,7 @@
 #include <array>
 #include <span>
 #include <thread>
-
-#include <SDL.h>
-#if SDL_VERSION_ATLEAST(2, 26, 4)
-#   include <SDL_hidapi.h>
-#else
-struct SDL_hid_device;
-struct SDL_hid_device_info;
-#endif
+#include <SDL_hidapi.h>
 
 #include "input_common/input_engine.h"
 

src/input_common/drivers/sdl_driver.cpp

@@ -42,7 +42,6 @@ public:
     }
 
     void EnableMotion() {
-#if SDL_VERSION_ATLEAST(2, 26, 4)
         if (!sdl_controller) {
             return;
         }
@@ -59,14 +58,12 @@ public:
         if (has_gyro) {
             SDL_GameControllerSetSensorEnabled(controller, SDL_SENSOR_GYRO, SDL_TRUE);
         }
-#endif
     }
 
     bool HasMotion() const {
         return has_gyro || has_accel;
     }
 
-#if SDL_VERSION_ATLEAST(2, 26, 4)
     bool UpdateMotion(SDL_ControllerSensorEvent event) {
         constexpr float gravity_constant = 9.80665f;
         std::scoped_lock lock{mutex};
@@ -108,7 +105,6 @@ public:
         motion.delta_timestamp = time_difference * 1000;
         return true;
     }
-#endif
 
     const BasicMotion& GetMotion() const {
         return motion;
@@ -153,15 +149,13 @@ public:
     }
 
     bool HasHDRumble() const {
-#if SDL_VERSION_ATLEAST(2, 26, 4)
         if (sdl_controller) {
-            auto const type = SDL_GameControllerGetType(sdl_controller.get());
+            const auto type = SDL_GameControllerGetType(sdl_controller.get());
             return (type == SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO) ||
                    (type == SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_LEFT) ||
                    (type == SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_RIGHT) ||
                    (type == SDL_CONTROLLER_TYPE_PS5);
         }
-#endif
         return false;
     }
 
@@ -258,21 +252,26 @@ public:
     }
 
     std::string GetControllerName() const {
-#if SDL_VERSION_ATLEAST(2, 26, 4)
         if (sdl_controller) {
             switch (SDL_GameControllerGetType(sdl_controller.get())) {
-            case SDL_CONTROLLER_TYPE_XBOX360: return "Xbox 360 Controller";
-            case SDL_CONTROLLER_TYPE_XBOXONE: return "Xbox One Controller";
-            case SDL_CONTROLLER_TYPE_PS3: return "DualShock 3 Controller";
-            case SDL_CONTROLLER_TYPE_PS4: return "DualShock 4 Controller";
-            case SDL_CONTROLLER_TYPE_PS5: return "DualSense Controller";
+            case SDL_CONTROLLER_TYPE_XBOX360:
+                return "Xbox 360 Controller";
+            case SDL_CONTROLLER_TYPE_XBOXONE:
+                return "Xbox One Controller";
+            case SDL_CONTROLLER_TYPE_PS3:
+                return "DualShock 3 Controller";
+            case SDL_CONTROLLER_TYPE_PS4:
+                return "DualShock 4 Controller";
+            case SDL_CONTROLLER_TYPE_PS5:
+                return "DualSense Controller";
             default:
-                if (auto const name = SDL_GameControllerName(sdl_controller.get()); name)
-                    return name;
                 break;
             }
+            const auto name = SDL_GameControllerName(sdl_controller.get());
+            if (name) {
+                return name;
+            }
         }
-#endif
 
         if (sdl_joystick) {
             const auto name = SDL_JoystickName(sdl_joystick.get());
@@ -457,7 +456,6 @@ void SDLDriver::HandleGameControllerEvent(const SDL_Event& event) {
         }
         break;
     }
-#if SDL_VERSION_ATLEAST(2, 26, 4)
     case SDL_CONTROLLERSENSORUPDATE: {
         if (auto joystick = GetSDLJoystickBySDLID(event.csensor.which)) {
             if (joystick->UpdateMotion(event.csensor)) {
@@ -474,7 +472,6 @@ void SDLDriver::HandleGameControllerEvent(const SDL_Event& event) {
         }
         break;
     }
-#endif
     case SDL_JOYDEVICEREMOVED:
         LOG_DEBUG(Input, "Controller removed with Instance_ID {}", event.jdevice.which);
         CloseJoystick(SDL_JoystickFromInstanceID(event.jdevice.which));
@@ -492,7 +489,6 @@ void SDLDriver::CloseJoysticks() {
 }
 
 SDLDriver::SDLDriver(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
-#if SDL_VERSION_ATLEAST(2, 26, 4)
     // Set our application name. Currently passed to DBus by SDL and visible to the user through
     // their desktop environment.
     SDL_SetHint(SDL_HINT_APP_NAME, "Eden");
@@ -535,7 +531,6 @@ SDLDriver::SDLDriver(std::string input_engine_) : InputEngine(std::move(input_en
     // Disable hidapi driver for xbox. Already default on Windows, this causes conflict with native
     // driver on Linux.
     SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_XBOX, "0");
-#endif
 
     // If the frontend is going to manage the event loop, then we don't start one here
     start_thread = SDL_WasInit(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) == 0;
@@ -840,7 +835,6 @@ ButtonBindings SDLDriver::GetDefaultButtonBinding(
     auto slr_button = SDL_CONTROLLER_BUTTON_LEFTSHOULDER;
     auto srr_button = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER;
 
-#if SDL_VERSION_ATLEAST(2, 26, 4)
     if (joystick->IsJoyconLeft()) {
         sll_button = SDL_CONTROLLER_BUTTON_PADDLE2;
         srl_button = SDL_CONTROLLER_BUTTON_PADDLE4;
@@ -849,7 +843,6 @@ ButtonBindings SDLDriver::GetDefaultButtonBinding(
         slr_button = SDL_CONTROLLER_BUTTON_PADDLE3;
         srr_button = SDL_CONTROLLER_BUTTON_PADDLE1;
     }
-#endif
 
     return {
         std::pair{Settings::NativeButton::A, SDL_CONTROLLER_BUTTON_B},
@@ -871,9 +864,7 @@ ButtonBindings SDLDriver::GetDefaultButtonBinding(
         {Settings::NativeButton::SLRight, slr_button},
         {Settings::NativeButton::SRRight, srr_button},
         {Settings::NativeButton::Home, SDL_CONTROLLER_BUTTON_GUIDE},
-#if SDL_VERSION_ATLEAST(2, 26, 4)
         {Settings::NativeButton::Screenshot, SDL_CONTROLLER_BUTTON_MISC1},
-#endif
     };
 }
 

src/input_common/helpers/joycon_driver.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -41,8 +38,8 @@ Common::Input::DriverResult JoyconDriver::RequestDeviceAccess(SDL_hid_device_inf
         return Common::Input::DriverResult::UnsupportedControllerType;
     }
 
-#if SDL_VERSION_ATLEAST(2, 26, 4)
-    hidapi_handle->handle = SDL_hid_open(device_info->vendor_id, device_info->product_id, device_info->serial_number);
+    hidapi_handle->handle =
+        SDL_hid_open(device_info->vendor_id, device_info->product_id, device_info->serial_number);
     std::memcpy(&handle_serial_number, device_info->serial_number, 15);
     if (!hidapi_handle->handle) {
         LOG_ERROR(Input, "Yuzu can't gain access to this device: ID {:04X}:{:04X}.",
@@ -51,9 +48,6 @@ Common::Input::DriverResult JoyconDriver::RequestDeviceAccess(SDL_hid_device_inf
     }
     SDL_hid_set_nonblocking(hidapi_handle->handle, 1);
     return Common::Input::DriverResult::Success;
-#else
-    return Common::Input::DriverResult::UnsupportedControllerType;
-#endif
 }
 
 Common::Input::DriverResult JoyconDriver::InitializeDevice() {
@@ -144,6 +138,8 @@ void JoyconDriver::InputThread(std::stop_token stop_token) {
     Common::SetCurrentThreadName("JoyconInput");
     input_thread_running = true;
 
+    // Max update rate is 5ms, ensure we are always able to read a bit faster
+    constexpr int ThreadDelay = 3;
     std::vector<u8> buffer(MaxBufferSize);
 
     while (!stop_token.stop_requested()) {
@@ -154,17 +150,14 @@ void JoyconDriver::InputThread(std::stop_token stop_token) {
             continue;
         }
 
-#if SDL_VERSION_ATLEAST(2, 26, 4)
-        // Max update rate is 5ms, ensure we are always able to read a bit faster
-        int constexpr thread_delay = 3;
         // By disabling the input thread we can ensure custom commands will succeed as no package is
         // skipped
         if (!disable_input_thread) {
-            status = SDL_hid_read_timeout(hidapi_handle->handle, buffer.data(), buffer.size(), thread_delay);
+            status = SDL_hid_read_timeout(hidapi_handle->handle, buffer.data(), buffer.size(),
+                                          ThreadDelay);
         } else {
-            std::this_thread::sleep_for(std::chrono::milliseconds(thread_delay));
+            std::this_thread::sleep_for(std::chrono::milliseconds(ThreadDelay));
         }
-#endif
 
         if (IsPayloadCorrect(status, buffer)) {
             OnNewData(buffer);
@@ -697,18 +690,19 @@ void JoyconDriver::SetCallbacks(const JoyconCallbacks& callbacks) {
     joycon_poller->SetCallbacks(callbacks);
 }
 
-Common::Input::DriverResult JoyconDriver::GetDeviceType(SDL_hid_device_info* device_info, ControllerType& controller_type) {
-#if SDL_VERSION_ATLEAST(2, 26, 4)
+Common::Input::DriverResult JoyconDriver::GetDeviceType(SDL_hid_device_info* device_info,
+                                                        ControllerType& controller_type) {
     static constexpr std::array<std::pair<u32, ControllerType>, 6> supported_devices{
         std::pair<u32, ControllerType>{0x2006, ControllerType::Left},
         {0x2007, ControllerType::Right},
         {0x2009, ControllerType::Pro},
     };
-
     constexpr u16 nintendo_vendor_id = 0x057e;
+
     controller_type = ControllerType::None;
-    if (device_info->vendor_id != nintendo_vendor_id)
+    if (device_info->vendor_id != nintendo_vendor_id) {
         return Common::Input::DriverResult::UnsupportedControllerType;
+    }
 
     for (const auto& [product_id, type] : supported_devices) {
         if (device_info->product_id == static_cast<u16>(product_id)) {
@@ -716,20 +710,16 @@ Common::Input::DriverResult JoyconDriver::GetDeviceType(SDL_hid_device_info* dev
             return Common::Input::DriverResult::Success;
         }
     }
-#endif
     return Common::Input::DriverResult::UnsupportedControllerType;
 }
 
-Common::Input::DriverResult JoyconDriver::GetSerialNumber(SDL_hid_device_info* device_info, SerialNumber& serial_number) {
-#if SDL_VERSION_ATLEAST(2, 26, 4)
+Common::Input::DriverResult JoyconDriver::GetSerialNumber(SDL_hid_device_info* device_info,
+                                                          SerialNumber& serial_number) {
     if (device_info->serial_number == nullptr) {
         return Common::Input::DriverResult::Unknown;
     }
     std::memcpy(&serial_number, device_info->serial_number, 15);
     return Common::Input::DriverResult::Success;
-#else
-    return Common::Input::DriverResult::Unknown;
-#endif
 }
 
 } // namespace InputCommon::Joycon

src/input_common/helpers/joycon_protocol/common_protocol.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -18,15 +15,11 @@ u8 JoyconCommonProtocol::GetCounter() {
 }
 
 void JoyconCommonProtocol::SetBlocking() {
-#if SDL_VERSION_ATLEAST(2, 26, 4)
     SDL_hid_set_nonblocking(hidapi_handle->handle, 0);
-#endif
 }
 
 void JoyconCommonProtocol::SetNonBlocking() {
-#if SDL_VERSION_ATLEAST(2, 26, 4)
     SDL_hid_set_nonblocking(hidapi_handle->handle, 1);
-#endif
 }
 
 Common::Input::DriverResult JoyconCommonProtocol::GetDeviceType(ControllerType& controller_type) {
@@ -42,23 +35,26 @@ Common::Input::DriverResult JoyconCommonProtocol::GetDeviceType(ControllerType&
     return result;
 }
 
-Common::Input::DriverResult JoyconCommonProtocol::CheckDeviceAccess(SDL_hid_device_info* device_info) {
+Common::Input::DriverResult JoyconCommonProtocol::CheckDeviceAccess(
+    SDL_hid_device_info* device_info) {
     ControllerType controller_type{ControllerType::None};
     const auto result = GetDeviceType(controller_type);
+
     if (result != Common::Input::DriverResult::Success || controller_type == ControllerType::None) {
         return Common::Input::DriverResult::UnsupportedControllerType;
     }
-#if SDL_VERSION_ATLEAST(2, 26, 4)
-    hidapi_handle->handle = SDL_hid_open(device_info->vendor_id, device_info->product_id, device_info->serial_number);
+
+    hidapi_handle->handle =
+        SDL_hid_open(device_info->vendor_id, device_info->product_id, device_info->serial_number);
+
     if (!hidapi_handle->handle) {
-        LOG_ERROR(Input, "Yuzu can't gain access to this device: ID {:04X}:{:04X}.", device_info->vendor_id, device_info->product_id);
+        LOG_ERROR(Input, "Yuzu can't gain access to this device: ID {:04X}:{:04X}.",
+                  device_info->vendor_id, device_info->product_id);
         return Common::Input::DriverResult::HandleInUse;
     }
+
     SetNonBlocking();
     return Common::Input::DriverResult::Success;
-#else
-    return Common::Input::DriverResult::UnsupportedControllerType;
-#endif
 }
 
 Common::Input::DriverResult JoyconCommonProtocol::SetReportMode(ReportMode report_mode) {
@@ -67,21 +63,21 @@ Common::Input::DriverResult JoyconCommonProtocol::SetReportMode(ReportMode repor
 }
 
 Common::Input::DriverResult JoyconCommonProtocol::SendRawData(std::span<const u8> buffer) {
-#if SDL_VERSION_ATLEAST(2, 26, 4)
-    auto const result = SDL_hid_write(hidapi_handle->handle, buffer.data(), buffer.size());
-    if (result == -1)
+    const auto result = SDL_hid_write(hidapi_handle->handle, buffer.data(), buffer.size());
+
+    if (result == -1) {
         return Common::Input::DriverResult::ErrorWritingData;
+    }
+
     return Common::Input::DriverResult::Success;
-#else
-    return Common::Input::DriverResult::ErrorWritingData;
-#endif
 }
 
-Common::Input::DriverResult JoyconCommonProtocol::GetSubCommandResponse(SubCommand sc, SubCommandResponse& output) {
-#if SDL_VERSION_ATLEAST(2, 26, 4)
+Common::Input::DriverResult JoyconCommonProtocol::GetSubCommandResponse(
+    SubCommand sc, SubCommandResponse& output) {
     constexpr int timeout_mili = 66;
     constexpr int MaxTries = 10;
     int tries = 0;
+
     do {
         int result = SDL_hid_read_timeout(hidapi_handle->handle, reinterpret_cast<u8*>(&output),
                                           sizeof(SubCommandResponse), timeout_mili);
@@ -92,8 +88,9 @@ Common::Input::DriverResult JoyconCommonProtocol::GetSubCommandResponse(SubComma
         if (tries++ > MaxTries) {
             return Common::Input::DriverResult::Timeout;
         }
-    } while (output.input_report.report_mode != ReportMode::SUBCMD_REPLY && output.sub_command != sc);
-#endif
+    } while (output.input_report.report_mode != ReportMode::SUBCMD_REPLY &&
+             output.sub_command != sc);
+
     return Common::Input::DriverResult::Success;
 }
 
@@ -221,11 +218,12 @@ Common::Input::DriverResult JoyconCommonProtocol::ConfigureMCU(const MCUConfig&
     return result;
 }
 
-Common::Input::DriverResult JoyconCommonProtocol::GetMCUDataResponse(ReportMode report_mode, MCUCommandResponse& output) {
-#if SDL_VERSION_ATLEAST(2, 26, 4)
+Common::Input::DriverResult JoyconCommonProtocol::GetMCUDataResponse(ReportMode report_mode,
+                                                                     MCUCommandResponse& output) {
     constexpr int TimeoutMili = 200;
     constexpr int MaxTries = 9;
     int tries = 0;
+
     do {
         int result = SDL_hid_read_timeout(hidapi_handle->handle, reinterpret_cast<u8*>(&output),
                                           sizeof(MCUCommandResponse), TimeoutMili);
@@ -236,8 +234,9 @@ Common::Input::DriverResult JoyconCommonProtocol::GetMCUDataResponse(ReportMode
         if (tries++ > MaxTries) {
             return Common::Input::DriverResult::Timeout;
         }
-    } while (output.input_report.report_mode != report_mode || output.mcu_report == MCUReport::EmptyAwaitingCmd);
-#endif
+    } while (output.input_report.report_mode != report_mode ||
+             output.mcu_report == MCUReport::EmptyAwaitingCmd);
+
     return Common::Input::DriverResult::Success;
 }
 

src/input_common/helpers/joycon_protocol/joycon_types.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -13,14 +10,7 @@
 
 #include <array>
 #include <functional>
-
-#include <SDL.h>
-#if SDL_VERSION_ATLEAST(2, 26, 4)
-#   include <SDL_hidapi.h>
-#else
-struct SDL_hid_device;
-struct SDL_hid_device_info;
-#endif
+#include <SDL_hidapi.h>
 
 #include "common/bit_field.h"
 #include "common/common_funcs.h"

src/input_common/main.cpp

@@ -82,10 +82,7 @@ struct InputSubsystem::Impl {
 #ifdef ENABLE_LIBUSB
         RegisterEngine("gcpad", gcadapter);
 #endif
-#ifndef __OPENORBIS__
-        // TODO: Issue in PS4, crash for UDP_client
         RegisterEngine("cemuhookudp", udp_client);
-#endif
         RegisterEngine("tas", tas_input);
         RegisterEngine("camera", camera);
 #ifdef ANDROID
@@ -119,9 +116,7 @@ struct InputSubsystem::Impl {
 #ifdef ENABLE_LIBUSB
         UnregisterEngine(gcadapter);
 #endif
-#ifndef __OPENORBIS__
         UnregisterEngine(udp_client);
-#endif
         UnregisterEngine(tas_input);
         UnregisterEngine(camera);
 #ifdef ANDROID
@@ -157,10 +152,8 @@ struct InputSubsystem::Impl {
         auto gcadapter_devices = gcadapter->GetInputDevices();
         devices.insert(devices.end(), gcadapter_devices.begin(), gcadapter_devices.end());
 #endif
-#ifndef __OPENORBIS__
         auto udp_devices = udp_client->GetInputDevices();
         devices.insert(devices.end(), udp_devices.begin(), udp_devices.end());
-#endif
 #ifdef HAVE_SDL2
         auto joycon_devices = joycon->GetInputDevices();
         devices.insert(devices.end(), joycon_devices.begin(), joycon_devices.end());
@@ -193,11 +186,9 @@ struct InputSubsystem::Impl {
             return gcadapter;
         }
 #endif
-#ifndef __OPENORBIS__
         if (engine == udp_client->GetEngineName()) {
             return udp_client;
         }
-#endif
 #ifdef HAVE_SDL2
         if (engine == sdl->GetEngineName()) {
             return sdl;
@@ -280,11 +271,9 @@ struct InputSubsystem::Impl {
             return true;
         }
 #endif
-#ifndef __OPENORBIS__
         if (engine == udp_client->GetEngineName()) {
             return true;
         }
-#endif
         if (engine == tas_input->GetEngineName()) {
             return true;
         }
@@ -311,9 +300,7 @@ struct InputSubsystem::Impl {
 #ifdef ENABLE_LIBUSB
         gcadapter->BeginConfiguration();
 #endif
-#ifndef __OPENORBIS__
         udp_client->BeginConfiguration();
-#endif
 #ifdef HAVE_SDL2
         sdl->BeginConfiguration();
         joycon->BeginConfiguration();
@@ -329,9 +316,7 @@ struct InputSubsystem::Impl {
 #ifdef ENABLE_LIBUSB
         gcadapter->EndConfiguration();
 #endif
-#ifndef __OPENORBIS__
         udp_client->EndConfiguration();
-#endif
 #ifdef HAVE_SDL2
         sdl->EndConfiguration();
         joycon->EndConfiguration();
@@ -356,9 +341,7 @@ struct InputSubsystem::Impl {
     std::shared_ptr<Mouse> mouse;
     std::shared_ptr<TouchScreen> touch_screen;
     std::shared_ptr<TasInput::Tas> tas_input;
-#ifndef __OPENORBIS__
     std::shared_ptr<CemuhookUDP::UDPClient> udp_client;
-#endif
     std::shared_ptr<Camera> camera;
     std::shared_ptr<VirtualAmiibo> virtual_amiibo;
     std::shared_ptr<VirtualGamepad> virtual_gamepad;
@@ -487,9 +470,7 @@ bool InputSubsystem::IsStickInverted(const Common::ParamPackage& params) const {
 }
 
 void InputSubsystem::ReloadInputDevices() {
-#ifndef __OPENORBIS__
     impl->udp_client.get()->ReloadSockets();
-#endif
 }
 
 void InputSubsystem::BeginMapping(Polling::InputType type) {

src/qt_common/config/uisettings.h

@@ -159,13 +159,7 @@ struct Values {
     Setting<bool> enable_discord_presence{linkage, false, "enable_discord_presence", Category::Ui};
 
     // logging
-    Setting<bool> show_console{linkage,
-#ifdef __OPENORBIS__
-        true,
-#else
-        false,
-#endif
-        "showConsole", Category::Ui};
+    Setting<bool> show_console{linkage, false, "showConsole", Category::Ui};
 
     // Screenshots
     Setting<bool> enable_screenshot_save_as{linkage, true, "enable_screenshot_save_as",

src/shader_recompiler/backend/spirv/emit_spirv_image.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -542,8 +545,9 @@ Id EmitImageFetch(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id c
         lod = Id{};
     }
     const ImageOperands operands(lod, ms);
-    return Emit(&EmitContext::OpImageSparseFetch, &EmitContext::OpImageFetch, ctx, inst, ctx.F32[4],
-                TextureImage(ctx, info, index), coords, operands.MaskOptional(), operands.Span());
+    return Emit(&EmitContext::OpImageSparseFetch, &EmitContext::OpImageFetch, ctx, inst,
+                ctx.F32[4], TextureImage(ctx, info, index), coords, operands.MaskOptional(),
+                operands.Span());
 }
 
 Id EmitImageQueryDimensions(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id lod,

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -315,6 +315,9 @@ void DefineSsbos(EmitContext& ctx, StorageTypeDefinition& type_def,
         ctx.Decorate(id, spv::Decoration::Binding, binding);
         ctx.Decorate(id, spv::Decoration::DescriptorSet, 0U);
         ctx.Name(id, fmt::format("ssbo{}", index));
+        if (!desc.is_written) {
+            ctx.Decorate(id, spv::Decoration::NonWritable);
+        }
         if (ctx.profile.supported_spirv >= 0x00010400) {
             ctx.interfaces.push_back(id);
         }
@@ -1432,6 +1435,9 @@ void EmitContext::DefineInputs(const IR::Program& program) {
     }
     if (info.uses_sample_id) {
         sample_id = DefineInput(*this, U32[1], false, spv::BuiltIn::SampleId);
+        if (stage == Stage::Fragment) {
+            Decorate(sample_id, spv::Decoration::Flat);
+        }
     }
     if (info.uses_is_helper_invocation) {
         is_helper_invocation = DefineInput(*this, U1, false, spv::BuiltIn::HelperInvocation);
@@ -1442,6 +1448,13 @@ void EmitContext::DefineInputs(const IR::Program& program) {
         subgroup_mask_le = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupLeMaskKHR);
         subgroup_mask_gt = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupGtMaskKHR);
         subgroup_mask_ge = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupGeMaskKHR);
+        if (stage == Stage::Fragment) {
+            Decorate(subgroup_mask_eq, spv::Decoration::Flat);
+            Decorate(subgroup_mask_lt, spv::Decoration::Flat);
+            Decorate(subgroup_mask_le, spv::Decoration::Flat);
+            Decorate(subgroup_mask_gt, spv::Decoration::Flat);
+            Decorate(subgroup_mask_ge, spv::Decoration::Flat);
+        }
     }
     if (info.uses_fswzadd || info.uses_subgroup_invocation_id || info.uses_subgroup_shuffles ||
         (profile.warp_size_potentially_larger_than_guest &&
@@ -1449,7 +1462,9 @@ void EmitContext::DefineInputs(const IR::Program& program) {
         AddCapability(spv::Capability::GroupNonUniform);
         subgroup_local_invocation_id =
             DefineInput(*this, U32[1], false, spv::BuiltIn::SubgroupLocalInvocationId);
-        Decorate(subgroup_local_invocation_id, spv::Decoration::Flat);
+        if (stage == Stage::Fragment) {
+            Decorate(subgroup_local_invocation_id, spv::Decoration::Flat);
+        }
     }
     if (info.uses_fswzadd) {
         const Id f32_one{Const(1.0f)};
@@ -1461,6 +1476,9 @@ void EmitContext::DefineInputs(const IR::Program& program) {
     }
     if (loads[IR::Attribute::PrimitiveId]) {
         primitive_id = DefineInput(*this, U32[1], false, spv::BuiltIn::PrimitiveId);
+        if (stage == Stage::Fragment) {
+            Decorate(primitive_id, spv::Decoration::Flat);
+        }
     }
     if (loads[IR::Attribute::Layer]) {
         AddCapability(spv::Capability::Geometry);
@@ -1552,17 +1570,21 @@ void EmitContext::DefineInputs(const IR::Program& program) {
         if (stage != Stage::Fragment) {
             continue;
         }
-        switch (info.interpolation[index]) {
-        case Interpolation::Smooth:
-            // Default
-            // Decorate(id, spv::Decoration::Smooth);
-            break;
-        case Interpolation::NoPerspective:
-            Decorate(id, spv::Decoration::NoPerspective);
-            break;
-        case Interpolation::Flat:
+        const bool is_integer = input_type == AttributeType::SignedInt ||
+                                input_type == AttributeType::UnsignedInt;
+        if (is_integer) {
             Decorate(id, spv::Decoration::Flat);
-            break;
+        } else {
+            switch (info.interpolation[index]) {
+            case Interpolation::Smooth:
+                break;
+            case Interpolation::NoPerspective:
+                Decorate(id, spv::Decoration::NoPerspective);
+                break;
+            case Interpolation::Flat:
+                Decorate(id, spv::Decoration::Flat);
+                break;
+            }
         }
     }
     if (stage == Stage::TessellationEval) {

src/video_core/buffer_cache/buffer_cache.h

@@ -1705,26 +1705,21 @@ Binding BufferCache<P>::StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
         return NULL_BINDING;
     }
 
-    // xbzk: New size logic. Fixes MCI.
-    // If ever the * comment below prove wrong, the 'if' block may be removed.
     const auto size = [&]() {
         const bool is_nvn_cbuf = cbuf_index == 0;
+        // The NVN driver buffer (index 0) is known to pack the SSBO address followed by its size.
         if (is_nvn_cbuf) {
-            // * The NVN driver buffer (index 0) is known to pack the SSBO address followed by its size.
-            const u64 next_qword = gpu_memory->Read<u64>(ssbo_addr + 8);
-            const u32 upper_32 = static_cast<u32>(next_qword >> 32);
-            // Hardware-based detection: GPU addresses have non-zero upper bits
-            if (upper_32 == 0) {
-                // This is a size field, not a GPU address
-                return static_cast<u32>(next_qword);  // Return lower_32
+            const u32 ssbo_size = gpu_memory->Read<u32>(ssbo_addr + 8);
+            if (ssbo_size != 0) {
+                return ssbo_size;
             }
         }
-        // Fall through: either not NVN cbuf (Doom Eternal & +), or NVN but ssbo_addr+8 is a GPU address (MCI)
+        // Other titles (notably Doom Eternal) may use STG/LDG on buffer addresses in custom defined
+        // cbufs, which do not store the sizes adjacent to the addresses, so use the fully
+        // mapped buffer size for now.
         const u32 memory_layout_size = static_cast<u32>(gpu_memory->GetMemoryLayoutSize(gpu_addr));
-        // Cap at 8MB to prevent allocator overflow from misinterpreted addresses
         return (std::min)(memory_layout_size, static_cast<u32>(8_MiB));
     }();
-
     // Alignment only applies to the offset of the buffer
     const u32 alignment = runtime.GetStorageBufferAlignment();
     const GPUVAddr aligned_gpu_addr = Common::AlignDown(gpu_addr, alignment);

src/video_core/renderer_vulkan/blit_image.cpp

@@ -525,18 +525,24 @@ BlitImageHelper::BlitImageHelper(const Device& device_, Scheduler& scheduler_,
           nullptr, PUSH_CONSTANT_RANGE<VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(float) * 4>))),
       full_screen_vert(BuildShader(device, FULL_SCREEN_TRIANGLE_VERT_SPV)),
       blit_color_to_color_frag(BuildShader(device, BLIT_COLOR_FLOAT_FRAG_SPV)),
-      blit_depth_stencil_frag(BuildShader(device, VULKAN_BLIT_DEPTH_STENCIL_FRAG_SPV)),
+      blit_depth_stencil_frag(device.IsExtShaderStencilExportSupported() 
+                             ? BuildShader(device, VULKAN_BLIT_DEPTH_STENCIL_FRAG_SPV) 
+                             : vk::ShaderModule{}),
       clear_color_vert(BuildShader(device, VULKAN_COLOR_CLEAR_VERT_SPV)),
       clear_color_frag(BuildShader(device, VULKAN_COLOR_CLEAR_FRAG_SPV)),
       clear_stencil_frag(BuildShader(device, VULKAN_DEPTHSTENCIL_CLEAR_FRAG_SPV)),
       convert_depth_to_float_frag(BuildShader(device, CONVERT_DEPTH_TO_FLOAT_FRAG_SPV)),
       convert_float_to_depth_frag(BuildShader(device, CONVERT_FLOAT_TO_DEPTH_FRAG_SPV)),
-      convert_abgr8_to_d24s8_frag(BuildShader(device, CONVERT_ABGR8_TO_D24S8_FRAG_SPV)),
+      convert_abgr8_to_d24s8_frag(device.IsExtShaderStencilExportSupported() 
+                                 ? BuildShader(device, CONVERT_ABGR8_TO_D24S8_FRAG_SPV) 
+                                 : vk::ShaderModule{}),
       convert_abgr8_to_d32f_frag(BuildShader(device, CONVERT_ABGR8_TO_D32F_FRAG_SPV)),
       convert_d32f_to_abgr8_frag(BuildShader(device, CONVERT_D32F_TO_ABGR8_FRAG_SPV)),
       convert_d24s8_to_abgr8_frag(BuildShader(device, CONVERT_D24S8_TO_ABGR8_FRAG_SPV)),
       convert_s8d24_to_abgr8_frag(BuildShader(device, CONVERT_S8D24_TO_ABGR8_FRAG_SPV)),
-      convert_abgr8_srgb_to_d24s8_frag(BuildShader(device, CONVERT_ABGR8_SRGB_TO_D24S8_FRAG_SPV)),
+      convert_abgr8_srgb_to_d24s8_frag(device.IsExtShaderStencilExportSupported() 
+                                      ? BuildShader(device, CONVERT_ABGR8_SRGB_TO_D24S8_FRAG_SPV) 
+                                      : vk::ShaderModule{}),
       convert_rgba_to_bgra_frag(BuildShader(device, CONVERT_RGBA8_TO_BGRA8_FRAG_SPV)),
       convert_yuv420_to_rgb_comp(BuildShader(device, CONVERT_YUV420_TO_RGB_COMP_SPV)),
       convert_rgb_to_yuv420_comp(BuildShader(device, CONVERT_RGB_TO_YUV420_COMP_SPV)),
@@ -667,6 +673,11 @@ void BlitImageHelper::ConvertR16ToD16(const Framebuffer* dst_framebuffer,
 
 void BlitImageHelper::ConvertABGR8ToD24S8(const Framebuffer* dst_framebuffer,
                                           const ImageView& src_image_view) {
+    if (!device.IsExtShaderStencilExportSupported()) {
+        // Shader requires VK_EXT_shader_stencil_export which is not available
+        LOG_WARNING(Render_Vulkan, "ConvertABGR8ToD24S8 requires shader_stencil_export, skipping");
+        return;
+    }
     ConvertPipelineDepthTargetEx(convert_abgr8_to_d24s8_pipeline, dst_framebuffer->RenderPass(),
                                  convert_abgr8_to_d24s8_frag);
     Convert(*convert_abgr8_to_d24s8_pipeline, dst_framebuffer, src_image_view);
@@ -702,6 +713,11 @@ void BlitImageHelper::ConvertS8D24ToABGR8(const Framebuffer* dst_framebuffer,
 
 void BlitImageHelper::ConvertABGR8SRGBToD24S8(const Framebuffer* dst_framebuffer,
                                              const ImageView& src_image_view) {
+    if (!device.IsExtShaderStencilExportSupported()) {
+        // Shader requires VK_EXT_shader_stencil_export which is not available
+        LOG_WARNING(Render_Vulkan, "ConvertABGR8SRGBToD24S8 requires shader_stencil_export, skipping");
+        return;
+    }
     ConvertPipelineDepthTargetEx(convert_abgr8_srgb_to_d24s8_pipeline,
                                 dst_framebuffer->RenderPass(),
                                 convert_abgr8_srgb_to_d24s8_frag);

src/video_core/renderer_vulkan/fixed_pipeline_state.cpp

@@ -59,7 +59,7 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
     raw1 = 0;
     extended_dynamic_state.Assign(features.has_extended_dynamic_state ? 1 : 0);
     extended_dynamic_state_2.Assign(features.has_extended_dynamic_state_2 ? 1 : 0);
-    extended_dynamic_state_2_extra.Assign(features.has_extended_dynamic_state_2_extra ? 1 : 0);
+    extended_dynamic_state_2_logic_op.Assign(features.has_extended_dynamic_state_2_logic_op ? 1 : 0);
     extended_dynamic_state_3_blend.Assign(features.has_extended_dynamic_state_3_blend ? 1 : 0);
     extended_dynamic_state_3_enables.Assign(features.has_extended_dynamic_state_3_enables ? 1 : 0);
     dynamic_vertex_input.Assign(features.has_dynamic_vertex_input ? 1 : 0);
@@ -157,7 +157,7 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
             return static_cast<u16>(array.stride.Value());
         });
     }
-    if (!extended_dynamic_state_2_extra) {
+    if (!extended_dynamic_state_2_logic_op) {
         dynamic_state.Refresh2(regs, topology_, extended_dynamic_state_2);
     }
     if (!extended_dynamic_state_3_blend) {

src/video_core/renderer_vulkan/fixed_pipeline_state.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -20,7 +23,8 @@ using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 struct DynamicFeatures {
     bool has_extended_dynamic_state;
     bool has_extended_dynamic_state_2;
-    bool has_extended_dynamic_state_2_extra;
+    bool has_extended_dynamic_state_2_logic_op;
+    bool has_extended_dynamic_state_2_patch_control_points;
     bool has_extended_dynamic_state_3_blend;
     bool has_extended_dynamic_state_3_enables;
     bool has_dynamic_vertex_input;
@@ -186,7 +190,7 @@ struct FixedPipelineState {
         u32 raw1;
         BitField<0, 1, u32> extended_dynamic_state;
         BitField<1, 1, u32> extended_dynamic_state_2;
-        BitField<2, 1, u32> extended_dynamic_state_2_extra;
+        BitField<2, 1, u32> extended_dynamic_state_2_logic_op;
         BitField<3, 1, u32> extended_dynamic_state_3_blend;
         BitField<4, 1, u32> extended_dynamic_state_3_enables;
         BitField<5, 1, u32> dynamic_vertex_input;

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -583,7 +583,9 @@ void BufferCacheRuntime::BindVertexBuffer(u32 index, VkBuffer buffer, u32 offset
     if (index >= device.GetMaxVertexInputBindings()) {
         return;
     }
-    if (device.IsExtExtendedDynamicStateSupported()) {
+    // Use BindVertexBuffers2EXT only if EDS1 is supported AND VIDS is not active
+    // When VIDS is active, the pipeline doesn't declare VERTEX_INPUT_BINDING_STRIDE as dynamic
+    if (device.IsExtExtendedDynamicStateSupported() && !device.IsExtVertexInputDynamicStateSupported()) {
         scheduler.Record([index, buffer, offset, size, stride](vk::CommandBuffer cmdbuf) {
             const VkDeviceSize vk_offset = buffer != VK_NULL_HANDLE ? offset : 0;
             const VkDeviceSize vk_size = buffer != VK_NULL_HANDLE ? size : VK_WHOLE_SIZE;
@@ -623,7 +625,8 @@ void BufferCacheRuntime::BindVertexBuffers(VideoCommon::HostBindings<Buffer>& bi
     if (binding_count == 0) {
         return;
     }
-    if (device.IsExtExtendedDynamicStateSupported()) {
+    // Use BindVertexBuffers2EXT only if EDS1 is supported AND VIDS is not active
+    if (device.IsExtExtendedDynamicStateSupported() && !device.IsExtVertexInputDynamicStateSupported()) {
         scheduler.Record([bindings_ = std::move(bindings),
                           buffer_handles_ = std::move(buffer_handles),
                           binding_count](vk::CommandBuffer cmdbuf) {

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -418,6 +418,9 @@ ConditionalRenderingResolvePass::ConditionalRenderingResolvePass(
 
 void ConditionalRenderingResolvePass::Resolve(VkBuffer dst_buffer, VkBuffer src_buffer,
                                               u32 src_offset, bool compare_to_zero) {
+    if (!device.IsExtConditionalRendering()) {
+        return;
+    }
     const size_t compare_size = compare_to_zero ? 8 : 24;
 
     compute_pass_descriptor_queue.Acquire();
@@ -448,7 +451,7 @@ void ConditionalRenderingResolvePass::Resolve(VkBuffer dst_buffer, VkBuffer src_
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});
         cmdbuf.Dispatch(1, 1, 1);
         cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                               VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT, 0, write_barrier);
+                               VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, write_barrier);
     });
 }
 
@@ -470,6 +473,14 @@ QueriesPrefixScanPass::QueriesPrefixScanPass(
 void QueriesPrefixScanPass::Run(VkBuffer accumulation_buffer, VkBuffer dst_buffer,
                                 VkBuffer src_buffer, size_t number_of_sums,
                                 size_t min_accumulation_limit, size_t max_accumulation_limit) {
+    constexpr VkAccessFlags BASE_DST_ACCESS = VK_ACCESS_SHADER_READ_BIT |
+                                              VK_ACCESS_TRANSFER_READ_BIT |
+                                              VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT |
+                                              VK_ACCESS_INDIRECT_COMMAND_READ_BIT |
+                                              VK_ACCESS_INDEX_READ_BIT |
+                                              VK_ACCESS_UNIFORM_READ_BIT;
+    const VkAccessFlags conditional_access =
+        device.IsExtConditionalRendering() ? VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT : 0;
     size_t current_runs = number_of_sums;
     size_t offset = 0;
     while (current_runs != 0) {
@@ -486,22 +497,18 @@ void QueriesPrefixScanPass::Run(VkBuffer accumulation_buffer, VkBuffer dst_buffe
 
         scheduler.RequestOutsideRenderPassOperationContext();
         scheduler.Record([this, descriptor_data, min_accumulation_limit, max_accumulation_limit,
-                          runs_to_do, used_offset](vk::CommandBuffer cmdbuf) {
+                          runs_to_do, used_offset, conditional_access](vk::CommandBuffer cmdbuf) {
             static constexpr VkMemoryBarrier read_barrier{
                 .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
                 .pNext = nullptr,
                 .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
                 .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
             };
-            static constexpr VkMemoryBarrier write_barrier{
+            const VkMemoryBarrier write_barrier{
                 .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
                 .pNext = nullptr,
                 .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
-                .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT |
-                                 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT |
-                                 VK_ACCESS_INDIRECT_COMMAND_READ_BIT | VK_ACCESS_INDEX_READ_BIT |
-                                 VK_ACCESS_UNIFORM_READ_BIT |
-                                 VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT,
+                .dstAccessMask = BASE_DST_ACCESS | conditional_access,
             };
             const QueriesPrefixScanPushConstants uniforms{
                 .min_accumulation_base = static_cast<u32>(min_accumulation_limit),
@@ -519,8 +526,7 @@ void QueriesPrefixScanPass::Run(VkBuffer accumulation_buffer, VkBuffer dst_buffe
             cmdbuf.PushConstants(*layout, VK_SHADER_STAGE_COMPUTE_BIT, uniforms);
             cmdbuf.Dispatch(1, 1, 1);
             cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                                   VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT, 0,
-                                   write_barrier);
+                                   VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, write_barrier);
         });
     }
 }

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -263,6 +263,7 @@ GraphicsPipeline::GraphicsPipeline(
         std::ranges::copy(info->constant_buffer_used_sizes, uniform_buffer_sizes[stage].begin());
         num_textures += Shader::NumDescriptors(info->texture_descriptors);
     }
+    fragment_has_color0_output = stage_infos[NUM_STAGES - 1].stores_frag_color[0];
     auto func{[this, shader_notify, &render_pass_cache, &descriptor_pool, pipeline_statistics] {
         DescriptorLayoutBuilder builder{MakeBuilder(device, stage_infos)};
         uses_push_descriptor = builder.CanUsePushDescriptor();
@@ -702,13 +703,18 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         .lineWidth = 1.0f,
         // TODO(alekpop): Transfer from regs
     };
+    const bool smooth_lines_supported =
+        device.IsExtLineRasterizationSupported() && device.SupportsSmoothLines();
+    const bool stippled_lines_supported =
+        device.IsExtLineRasterizationSupported() && device.SupportsStippledRectangularLines();
     VkPipelineRasterizationLineStateCreateInfoEXT line_state{
         .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT,
         .pNext = nullptr,
-        .lineRasterizationMode = key.state.smooth_lines != 0
+        .lineRasterizationMode = key.state.smooth_lines != 0 && smooth_lines_supported
                                      ? VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT
                                      : VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT,
-        .stippledLineEnable = dynamic.line_stipple_enable ? VK_TRUE : VK_FALSE,
+        .stippledLineEnable =
+            (dynamic.line_stipple_enable && stippled_lines_supported) ? VK_TRUE : VK_FALSE,
         .lineStippleFactor = key.state.line_stipple_factor,
         .lineStipplePattern = static_cast<uint16_t>(key.state.line_stipple_pattern),
     };
@@ -739,6 +745,8 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         provoking_vertex.pNext = std::exchange(rasterization_ci.pNext, &provoking_vertex);
     }
 
+    const bool supports_alpha_output = fragment_has_color0_output;
+    const bool alpha_to_one_supported = device.SupportsAlphaToOne();
     const VkPipelineMultisampleStateCreateInfo multisample_ci{
         .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
         .pNext = nullptr,
@@ -747,8 +755,10 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         .sampleShadingEnable = Settings::values.sample_shading.GetValue() ? VK_TRUE : VK_FALSE,
         .minSampleShading = static_cast<float>(Settings::values.sample_shading_fraction.GetValue()) / 100.0f,
         .pSampleMask = nullptr,
-        .alphaToCoverageEnable = key.state.alpha_to_coverage_enabled != 0 ? VK_TRUE : VK_FALSE,
-        .alphaToOneEnable = key.state.alpha_to_one_enabled != 0 ? VK_TRUE : VK_FALSE,
+        .alphaToCoverageEnable =
+            supports_alpha_output && key.state.alpha_to_coverage_enabled != 0 ? VK_TRUE : VK_FALSE,
+        .alphaToOneEnable = supports_alpha_output && alpha_to_one_supported &&
+                           key.state.alpha_to_one_enabled != 0 ? VK_TRUE : VK_FALSE,
     };
     const VkPipelineDepthStencilStateCreateInfo depth_stencil_ci{
         .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
@@ -806,14 +816,25 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         .blendConstants = {}
     };
     static_vector<VkDynamicState, 34> dynamic_states{
-        VK_DYNAMIC_STATE_VIEWPORT,           VK_DYNAMIC_STATE_SCISSOR,
-        VK_DYNAMIC_STATE_DEPTH_BIAS,         VK_DYNAMIC_STATE_BLEND_CONSTANTS,
-        VK_DYNAMIC_STATE_DEPTH_BOUNDS,       VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
-        VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, VK_DYNAMIC_STATE_STENCIL_REFERENCE,
+        VK_DYNAMIC_STATE_VIEWPORT,
+        VK_DYNAMIC_STATE_SCISSOR,
+        VK_DYNAMIC_STATE_DEPTH_BIAS,
         VK_DYNAMIC_STATE_LINE_WIDTH,
     };
+
+    if (device.UsesAdvancedCoreDynamicState()) {
+        static constexpr std::array core_dynamic_states{
+            VK_DYNAMIC_STATE_BLEND_CONSTANTS,
+            VK_DYNAMIC_STATE_DEPTH_BOUNDS,
+            VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
+            VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
+            VK_DYNAMIC_STATE_STENCIL_REFERENCE,
+        };
+        dynamic_states.insert(dynamic_states.end(), core_dynamic_states.begin(),
+                              core_dynamic_states.end());
+    }
     if (key.state.extended_dynamic_state) {
-        std::vector<VkDynamicState> extended{
+        static constexpr std::array extended{
             VK_DYNAMIC_STATE_CULL_MODE_EXT,
             VK_DYNAMIC_STATE_FRONT_FACE_EXT,
             VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT,
@@ -823,51 +844,68 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
             VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT,
             VK_DYNAMIC_STATE_STENCIL_OP_EXT,
         };
-        if (!device.IsExtVertexInputDynamicStateSupported()) {
-            extended.push_back(VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT);
-        }
-        if (key.state.dynamic_vertex_input) {
-            dynamic_states.push_back(VK_DYNAMIC_STATE_VERTEX_INPUT_EXT);
-        }
         dynamic_states.insert(dynamic_states.end(), extended.begin(), extended.end());
-        if (key.state.extended_dynamic_state_2) {
-            static constexpr std::array extended2{
-                VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT,
-                VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT,
-                VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT,
-            };
-            dynamic_states.insert(dynamic_states.end(), extended2.begin(), extended2.end());
+        
+        // VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT is part of EDS1
+        // Only use it if VIDS is not active (VIDS replaces it with full vertex input control)
+        if (!key.state.dynamic_vertex_input) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT);
         }
-        if (key.state.extended_dynamic_state_2_extra) {
-            dynamic_states.push_back(VK_DYNAMIC_STATE_LOGIC_OP_EXT);
+    }
+    
+    // VK_DYNAMIC_STATE_VERTEX_INPUT_EXT (VIDS) - Independent from EDS
+    // Provides full dynamic vertex input control, replaces VERTEX_INPUT_BINDING_STRIDE
+    if (key.state.dynamic_vertex_input) {
+        dynamic_states.push_back(VK_DYNAMIC_STATE_VERTEX_INPUT_EXT);
+    }
+    
+    // EDS2 - Core (3 states)
+    if (key.state.extended_dynamic_state_2) {
+        static constexpr std::array extended2{
+            VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT,
+            VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT,
+            VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT,
+        };
+        dynamic_states.insert(dynamic_states.end(), extended2.begin(), extended2.end());
+    }
+    
+    // EDS2 - LogicOp (granular)
+    if (key.state.extended_dynamic_state_2_logic_op) {
+        dynamic_states.push_back(VK_DYNAMIC_STATE_LOGIC_OP_EXT);
+    }
+    
+    // EDS3 - Blending (composite: 3 states)
+    if (key.state.extended_dynamic_state_3_blend) {
+        static constexpr std::array extended3{
+            VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT,
+            VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT,
+            VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT,
+        };
+        dynamic_states.insert(dynamic_states.end(), extended3.begin(), extended3.end());
+    }
+    
+    // EDS3 - Enables (composite: per-feature)
+    if (key.state.extended_dynamic_state_3_enables) {
+        if (device.SupportsDynamicState3DepthClampEnable()) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT);
         }
-        if (key.state.extended_dynamic_state_3_blend) {
-            static constexpr std::array extended3{
-                VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT,
-                VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT,
-                VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT,
-
-                // VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT,
-            };
-            dynamic_states.insert(dynamic_states.end(), extended3.begin(), extended3.end());
+        if (device.SupportsDynamicState3LogicOpEnable()) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT);
         }
-        if (key.state.extended_dynamic_state_3_enables) {
-            static constexpr std::array extended3{
-                VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT,
-                VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT,
-
-                // additional state3 extensions
-                VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT,
-
-                VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT,
-
-                VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT,
-                VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT,
-                VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT,
-                VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT,
-                VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT,
-            };
-            dynamic_states.insert(dynamic_states.end(), extended3.begin(), extended3.end());
+        if (device.SupportsDynamicState3LineRasterizationMode()) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT);
+        }
+        if (device.SupportsDynamicState3ConservativeRasterizationMode()) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT);
+        }
+        if (device.SupportsDynamicState3LineStippleEnable()) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT);
+        }
+        if (device.SupportsDynamicState3AlphaToCoverageEnable()) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT);
+        }
+        if (device.SupportsDynamicState3AlphaToOneEnable()) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT);
         }
     }
 

src/video_core/renderer_vulkan/vk_graphics_pipeline.h

@@ -82,6 +82,17 @@ public:
         const std::array<const Shader::Info*, NUM_STAGES>& infos);
 
     bool HasDynamicVertexInput() const noexcept { return key.state.dynamic_vertex_input; }
+    bool SupportsAlphaToCoverage() const noexcept {
+        return fragment_has_color0_output;
+    }
+
+    bool SupportsAlphaToOne() const noexcept {
+        return fragment_has_color0_output;
+    }
+
+    bool UsesExtendedDynamicState() const noexcept {
+        return key.state.extended_dynamic_state != 0;
+    }
     GraphicsPipeline& operator=(GraphicsPipeline&&) noexcept = delete;
     GraphicsPipeline(GraphicsPipeline&&) noexcept = delete;
 
@@ -149,6 +160,7 @@ private:
     std::array<u32, 5> enabled_uniform_buffer_masks{};
     VideoCommon::UniformBufferSizes uniform_buffer_sizes{};
     u32 num_textures{};
+    bool fragment_has_color0_output{};
 
     vk::DescriptorSetLayout descriptor_set_layout;
     DescriptorAllocator descriptor_allocator;

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -146,7 +146,8 @@ Shader::AttributeType AttributeType(const FixedPipelineState& state, size_t inde
 Shader::RuntimeInfo MakeRuntimeInfo(std::span<const Shader::IR::Program> programs,
                                     const GraphicsPipelineCacheKey& key,
                                     const Shader::IR::Program& program,
-                                    const Shader::IR::Program* previous_program) {
+                                    const Shader::IR::Program* previous_program,
+                                    const Vulkan::Device& device) {
     Shader::RuntimeInfo info;
     if (previous_program) {
         info.previous_stage_stores = previous_program->info.stores;
@@ -168,10 +169,14 @@ Shader::RuntimeInfo MakeRuntimeInfo(std::span<const Shader::IR::Program> program
                 info.fixed_state_point_size = point_size;
             }
             if (key.state.xfb_enabled) {
-                auto [varyings, count] =
-                    VideoCommon::MakeTransformFeedbackVaryings(key.state.xfb_state);
-                info.xfb_varyings = varyings;
-                info.xfb_count = count;
+                if (device.IsExtTransformFeedbackSupported()) {
+                    auto [varyings, count] =
+                        VideoCommon::MakeTransformFeedbackVaryings(key.state.xfb_state);
+                    info.xfb_varyings = varyings;
+                    info.xfb_count = count;
+                } else {
+                    LOG_WARNING(Render_Vulkan, "XFB requested in pipeline key but device lacks VK_EXT_transform_feedback; ignoring XFB decorations");
+                }
             }
             info.convert_depth_mode = gl_ndc;
         }
@@ -218,10 +223,14 @@ Shader::RuntimeInfo MakeRuntimeInfo(std::span<const Shader::IR::Program> program
             info.fixed_state_point_size = point_size;
         }
         if (key.state.xfb_enabled != 0) {
-            auto [varyings, count] =
-                VideoCommon::MakeTransformFeedbackVaryings(key.state.xfb_state);
-            info.xfb_varyings = varyings;
-            info.xfb_count = count;
+            if (device.IsExtTransformFeedbackSupported()) {
+                auto [varyings, count] =
+                    VideoCommon::MakeTransformFeedbackVaryings(key.state.xfb_state);
+                info.xfb_varyings = varyings;
+                info.xfb_count = count;
+            } else {
+                LOG_WARNING(Render_Vulkan, "XFB requested in pipeline key but device lacks VK_EXT_transform_feedback; ignoring XFB decorations");
+            }
         }
         info.convert_depth_mode = gl_ndc;
         break;
@@ -404,14 +413,35 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
                     device.GetMaxVertexInputBindings(), Maxwell::NumVertexArrays);
     }
 
-    dynamic_features = DynamicFeatures{
-        .has_extended_dynamic_state = device.IsExtExtendedDynamicStateSupported(),
-        .has_extended_dynamic_state_2 = device.IsExtExtendedDynamicState2Supported(),
-        .has_extended_dynamic_state_2_extra = device.IsExtExtendedDynamicState2ExtrasSupported(),
-        .has_extended_dynamic_state_3_blend = device.IsExtExtendedDynamicState3BlendingSupported(),
-        .has_extended_dynamic_state_3_enables = device.IsExtExtendedDynamicState3EnablesSupported(),
-        .has_dynamic_vertex_input = device.IsExtVertexInputDynamicStateSupported(),
-    };
+    LOG_INFO(Render_Vulkan, "DynamicState setting value: {}", Settings::values.dyna_state.GetValue());
+    
+    dynamic_features = {};
+    
+    // User granularity enforced in vulkan_device.cpp switch statement:
+    //   Level 0: Core Dynamic States only
+    //   Level 1: Core + EDS1
+    //   Level 2: Core + EDS1 + EDS2 (accumulative)
+    //   Level 3: Core + EDS1 + EDS2 + EDS3 (accumulative)
+    // Here we only verify if extensions were successfully loaded by the device
+    
+    dynamic_features.has_extended_dynamic_state = 
+        device.IsExtExtendedDynamicStateSupported();
+    
+    dynamic_features.has_extended_dynamic_state_2 = 
+        device.IsExtExtendedDynamicState2Supported();
+    dynamic_features.has_extended_dynamic_state_2_logic_op = 
+        device.IsExtExtendedDynamicState2ExtrasSupported();
+    dynamic_features.has_extended_dynamic_state_2_patch_control_points = false;
+    
+    dynamic_features.has_extended_dynamic_state_3_blend = 
+        device.IsExtExtendedDynamicState3BlendingSupported();
+    dynamic_features.has_extended_dynamic_state_3_enables = 
+        device.IsExtExtendedDynamicState3EnablesSupported();
+    
+    // VIDS: Independent toggle (not affected by dyna_state levels)
+    dynamic_features.has_dynamic_vertex_input = 
+        device.IsExtVertexInputDynamicStateSupported() && 
+        Settings::values.vertex_input_dynamic_state.GetValue();
 }
 
 PipelineCache::~PipelineCache() {
@@ -516,8 +546,8 @@ void PipelineCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading
                 dynamic_features.has_extended_dynamic_state ||
             (key.state.extended_dynamic_state_2 != 0) !=
                 dynamic_features.has_extended_dynamic_state_2 ||
-            (key.state.extended_dynamic_state_2_extra != 0) !=
-                dynamic_features.has_extended_dynamic_state_2_extra ||
+            (key.state.extended_dynamic_state_2_logic_op != 0) !=
+                dynamic_features.has_extended_dynamic_state_2_logic_op ||
             (key.state.extended_dynamic_state_3_blend != 0) !=
                 dynamic_features.has_extended_dynamic_state_3_blend ||
             (key.state.extended_dynamic_state_3_enables != 0) !=
@@ -671,7 +701,7 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
         const size_t stage_index{index - 1};
         infos[stage_index] = &program.info;
 
-        const auto runtime_info{MakeRuntimeInfo(programs, key, program, previous_stage)};
+        const auto runtime_info{MakeRuntimeInfo(programs, key, program, previous_stage, device)};
         ConvertLegacyToGeneric(program, runtime_info);
         const std::vector<u32> code{EmitSPIRV(profile, runtime_info, program, binding, this->optimize_spirv_output)};
         device.SaveShader(code);

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -872,17 +872,18 @@ private:
             return;
         }
         has_flushed_end_pending = true;
-        if (!has_started || buffers_count == 0) {
+        // Refresh buffers state before beginning transform feedback so counters are up-to-date
+        UpdateBuffers();
+        if (buffers_count == 0) {
+            // No counter buffers available: begin without counters
             scheduler.Record([](vk::CommandBuffer cmdbuf) {
                 cmdbuf.BeginTransformFeedbackEXT(0, 0, nullptr, nullptr);
             });
-            UpdateBuffers();
             return;
         }
         scheduler.Record([this, total = static_cast<u32>(buffers_count)](vk::CommandBuffer cmdbuf) {
             cmdbuf.BeginTransformFeedbackEXT(0, total, counter_buffers.data(), offsets.data());
         });
-        UpdateBuffers();
     }
 
     void FlushEndTFB() {
@@ -892,11 +893,15 @@ private:
         }
         has_flushed_end_pending = false;
 
+        // Refresh buffer state before ending transform feedback to ensure counters_count is up-to-date.
+        UpdateBuffers();
         if (buffers_count == 0) {
+            LOG_DEBUG(Render_Vulkan, "EndTransformFeedbackEXT called with no counters (buffers_count=0)");
             scheduler.Record([](vk::CommandBuffer cmdbuf) {
                 cmdbuf.EndTransformFeedbackEXT(0, 0, nullptr, nullptr);
             });
         } else {
+            LOG_DEBUG(Render_Vulkan, "EndTransformFeedbackEXT called with counters (buffers_count={})", buffers_count);
             scheduler.Record([this,
                               total = static_cast<u32>(buffers_count)](vk::CommandBuffer cmdbuf) {
                 cmdbuf.EndTransformFeedbackEXT(0, total, counter_buffers.data(), offsets.data());
@@ -907,6 +912,7 @@ private:
     void UpdateBuffers() {
         last_queries.fill(0);
         last_queries_stride.fill(1);
+        streams_mask = 0; // reset previously recorded streams
         runtime.View3DRegs([this](Maxwell3D& maxwell3d) {
             buffers_count = 0;
             out_topology = maxwell3d.draw_manager->GetDrawState().topology;
@@ -916,6 +922,10 @@ private:
                     continue;
                 }
                 const size_t stream = tf.controls[i].stream;
+                if (stream >= last_queries_stride.size()) {
+                    LOG_WARNING(Render_Vulkan, "TransformFeedback stream {} out of range", stream);
+                    continue;
+                }
                 last_queries_stride[stream] = tf.controls[i].stride;
                 streams_mask |= 1ULL << stream;
                 buffers_count = std::max<size_t>(buffers_count, stream + 1);
@@ -1116,16 +1126,21 @@ public:
 
             query->flags |= VideoCommon::QueryFlagBits::IsFinalValueSynced;
             u64 num_vertices = 0;
+            // Protect against stride == 0 (avoid divide-by-zero). Use fallback stride=1 and warn.
+            u64 safe_stride = query->stride == 0 ? 1 : query->stride;
+            if (query->stride == 0) {
+                LOG_WARNING(Render_Vulkan, "TransformFeedback query has stride 0; using 1 to avoid div-by-zero (addr=0x{:x})", query->dependant_address);
+            }
             if (query->dependant_manage) {
                 auto* dependant_query = tfb_streamer.GetQuery(query->dependant_index);
-                num_vertices = dependant_query->value / query->stride;
+                num_vertices = dependant_query->value / safe_stride;
                 tfb_streamer.Free(query->dependant_index);
             } else {
                 u8* pointer = device_memory.GetPointer<u8>(query->dependant_address);
                 if (pointer != nullptr) {
                     u32 result;
                     std::memcpy(&result, pointer, sizeof(u32));
-                    num_vertices = static_cast<u64>(result) / query->stride;
+                    num_vertices = static_cast<u64>(result) / safe_stride;
                 }
             }
             query->value = [&]() -> u64 {

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -197,6 +197,11 @@ RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra
       fence_manager(*this, gpu, texture_cache, buffer_cache, query_cache, device, scheduler),
       wfi_event(device.GetLogical().CreateEvent()) {
     scheduler.SetQueryCache(query_cache);
+    
+    // Log multi-draw support
+    if (device.IsExtMultiDrawSupported()) {
+        LOG_INFO(Render_Vulkan, "VK_EXT_multi_draw is enabled for optimized draw calls");
+    }
 }
 
 RasterizerVulkan::~RasterizerVulkan() = default;
@@ -234,16 +239,44 @@ void RasterizerVulkan::Draw(bool is_indexed, u32 instance_count) {
         const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
         const u32 num_instances{instance_count};
         const DrawParams draw_params{MakeDrawParams(draw_state, num_instances, is_indexed)};
-        scheduler.Record([draw_params](vk::CommandBuffer cmdbuf) {
-            if (draw_params.is_indexed) {
-                cmdbuf.DrawIndexed(draw_params.num_vertices, draw_params.num_instances,
-                                   draw_params.first_index, draw_params.base_vertex,
-                                   draw_params.base_instance);
-            } else {
-                cmdbuf.Draw(draw_params.num_vertices, draw_params.num_instances,
-                            draw_params.base_vertex, draw_params.base_instance);
-            }
-        });
+        
+        // Use VK_EXT_multi_draw if available (single draw becomes multi-draw with count=1)
+        if (device.IsExtMultiDrawSupported()) {
+            scheduler.Record([draw_params](vk::CommandBuffer cmdbuf) {
+                if (draw_params.is_indexed) {
+                    // Use multi-draw indexed with single draw
+                    const VkMultiDrawIndexedInfoEXT multi_draw_info{
+                        .firstIndex = draw_params.first_index,
+                        .indexCount = draw_params.num_vertices,
+                    };
+                    const int32_t vertex_offset = static_cast<int32_t>(draw_params.base_vertex);
+                    cmdbuf.DrawMultiIndexedEXT(1, &multi_draw_info, draw_params.num_instances,
+                                               draw_params.base_instance,
+                                               sizeof(VkMultiDrawIndexedInfoEXT), &vertex_offset);
+                } else {
+                    // Use multi-draw with single draw
+                    const VkMultiDrawInfoEXT multi_draw_info{
+                        .firstVertex = draw_params.base_vertex,
+                        .vertexCount = draw_params.num_vertices,
+                    };
+                    cmdbuf.DrawMultiEXT(1, &multi_draw_info, draw_params.num_instances,
+                                        draw_params.base_instance,
+                                        sizeof(VkMultiDrawInfoEXT));
+                }
+            });
+        } else {
+            // Fallback to standard draw calls
+            scheduler.Record([draw_params](vk::CommandBuffer cmdbuf) {
+                if (draw_params.is_indexed) {
+                    cmdbuf.DrawIndexed(draw_params.num_vertices, draw_params.num_instances,
+                                       draw_params.first_index, draw_params.base_vertex,
+                                       draw_params.base_instance);
+                } else {
+                    cmdbuf.Draw(draw_params.num_vertices, draw_params.num_instances,
+                                draw_params.base_vertex, draw_params.base_instance);
+                }
+            });
+        }
     });
 }
 
@@ -386,13 +419,48 @@ void RasterizerVulkan::Clear(u32 layer_count) {
         .baseArrayLayer = regs.clear_surface.layer,
         .layerCount = layer_count,
     };
-    if (clear_rect.rect.extent.width == 0 || clear_rect.rect.extent.height == 0) {
+    const auto clamp_rect_to_render_area = [render_area](VkRect2D& rect) -> bool {
+        const auto clamp_axis = [](s32& offset, u32& extent, u32 limit) {
+            auto clamp_offset = [&offset, limit]() {
+                if (limit == 0) {
+                    offset = 0;
+                    return;
+                }
+                offset = std::clamp(offset, 0, static_cast<s32>(limit));
+            };
+
+            if (extent == 0) {
+                clamp_offset();
+                return;
+            }
+            if (offset < 0) {
+                const u32 shrink = (std::min)(extent, static_cast<u32>(-offset));
+                extent -= shrink;
+                offset = 0;
+            }
+            if (limit == 0) {
+                extent = 0;
+                offset = 0;
+                return;
+            }
+            if (offset >= static_cast<s32>(limit)) {
+                offset = static_cast<s32>(limit);
+                extent = 0;
+                return;
+            }
+            const u64 end_coord = static_cast<u64>(offset) + extent;
+            if (end_coord > limit) {
+                extent = limit - static_cast<u32>(offset);
+            }
+        };
+
+        clamp_axis(rect.offset.x, rect.extent.width, render_area.width);
+        clamp_axis(rect.offset.y, rect.extent.height, render_area.height);
+        return rect.extent.width != 0 && rect.extent.height != 0;
+    };
+    if (!clamp_rect_to_render_area(clear_rect.rect)) {
         return;
     }
-    clear_rect.rect.extent = VkExtent2D{
-        .width = (std::min)(clear_rect.rect.extent.width, render_area.width),
-        .height = (std::min)(clear_rect.rect.extent.height, render_area.height),
-    };
 
     const u32 color_attachment = regs.clear_surface.RT;
     if (use_color && framebuffer->HasAspectColorBit(color_attachment)) {
@@ -839,23 +907,21 @@ void RasterizerVulkan::LoadDiskResources(u64 title_id, std::stop_token stop_load
 
 void RasterizerVulkan::FlushWork() {
 #ifdef ANDROID
-    static constexpr u32 DRAWS_TO_DISPATCH = 1024;
+    static constexpr u32 DRAWS_TO_DISPATCH = 512;
+    static constexpr u32 CHECK_MASK = 3;
 #else
     static constexpr u32 DRAWS_TO_DISPATCH = 4096;
+    static constexpr u32 CHECK_MASK = 7;
 #endif // ANDROID
 
-    // Only check multiples of 8 draws
-    static_assert(DRAWS_TO_DISPATCH % 8 == 0);
-    if ((++draw_counter & 7) != 7) {
+    static_assert(DRAWS_TO_DISPATCH % (CHECK_MASK + 1) == 0);
+    if ((++draw_counter & CHECK_MASK) != CHECK_MASK) {
         return;
     }
     if (draw_counter < DRAWS_TO_DISPATCH) {
-        // Send recorded tasks to the worker thread
         scheduler.DispatchWork();
         return;
     }
-    // Otherwise (every certain number of draws) flush execution.
-    // This submits commands to the Vulkan driver.
     scheduler.Flush();
     draw_counter = 0;
 }
@@ -921,6 +987,8 @@ bool AccelerateDMA::BufferToImage(const Tegra::DMA::ImageCopy& copy_info,
 
 void RasterizerVulkan::UpdateDynamicStates() {
     auto& regs = maxwell3d->regs;
+    
+    // Core Dynamic States (Vulkan 1.0) - Always active regardless of dyna_state setting
     UpdateViewportsState(regs);
     UpdateScissorsState(regs);
     UpdateDepthBias(regs);
@@ -928,6 +996,8 @@ void RasterizerVulkan::UpdateDynamicStates() {
     UpdateDepthBounds(regs);
     UpdateStencilFaces(regs);
     UpdateLineWidth(regs);
+    
+    // EDS1: CullMode, DepthCompare, FrontFace, StencilOp, DepthBoundsTest, DepthTest, DepthWrite, StencilTest
     if (device.IsExtExtendedDynamicStateSupported()) {
         UpdateCullMode(regs);
         UpdateDepthCompareOp(regs);
@@ -938,40 +1008,52 @@ void RasterizerVulkan::UpdateDynamicStates() {
             UpdateDepthTestEnable(regs);
             UpdateDepthWriteEnable(regs);
             UpdateStencilTestEnable(regs);
-            if (device.IsExtExtendedDynamicState2Supported()) {
-                UpdatePrimitiveRestartEnable(regs);
-                UpdateRasterizerDiscardEnable(regs);
-                UpdateDepthBiasEnable(regs);
-            }
-            if (device.IsExtExtendedDynamicState3EnablesSupported()) {
-                using namespace Tegra::Engines;
-                if (device.GetDriverID() == VkDriverIdKHR::VK_DRIVER_ID_AMD_OPEN_SOURCE || device.GetDriverID() == VkDriverIdKHR::VK_DRIVER_ID_AMD_PROPRIETARY) {
-                    const auto has_float = std::any_of(
-                        regs.vertex_attrib_format.begin(),
-                        regs.vertex_attrib_format.end(),
-                        [](const auto& attrib) {
-                            return attrib.type == Maxwell3D::Regs::VertexAttribute::Type::Float;
-                        }
-                    );
-                    if (regs.logic_op.enable) {
-                        regs.logic_op.enable = static_cast<u32>(!has_float);
-                    }
-                }
-                UpdateLogicOpEnable(regs);
-                UpdateDepthClampEnable(regs);
-            }
-        }
-        if (device.IsExtExtendedDynamicState2ExtrasSupported()) {
-            UpdateLogicOp(regs);
-        }
-        if (device.IsExtExtendedDynamicState3BlendingSupported()) {
-            UpdateBlending(regs);
-        }
-        if (device.IsExtExtendedDynamicState3EnablesSupported()) {
-            UpdateLineStippleEnable(regs);
-            UpdateConservativeRasterizationMode(regs);
         }
     }
+    
+    // EDS2: PrimitiveRestart, RasterizerDiscard, DepthBias enable/disable
+    if (device.IsExtExtendedDynamicState2Supported()) {
+        UpdatePrimitiveRestartEnable(regs);
+        UpdateRasterizerDiscardEnable(regs);
+        UpdateDepthBiasEnable(regs);
+    }
+    
+    // EDS2 Extras: LogicOp operation selection
+    if (device.IsExtExtendedDynamicState2ExtrasSupported()) {
+        UpdateLogicOp(regs);
+    }
+    
+    // EDS3 Enables: LogicOpEnable, DepthClamp, LineStipple, ConservativeRaster
+    if (device.IsExtExtendedDynamicState3EnablesSupported()) {
+        using namespace Tegra::Engines;
+        // AMD Workaround: LogicOp incompatible with float render targets
+        if (device.GetDriverID() == VkDriverIdKHR::VK_DRIVER_ID_AMD_OPEN_SOURCE ||
+            device.GetDriverID() == VkDriverIdKHR::VK_DRIVER_ID_AMD_PROPRIETARY) {
+            const auto has_float = std::any_of(
+                regs.vertex_attrib_format.begin(), regs.vertex_attrib_format.end(),
+                [](const auto& attrib) {
+                    return attrib.type == Maxwell3D::Regs::VertexAttribute::Type::Float;
+                }
+            );
+            if (regs.logic_op.enable) {
+                regs.logic_op.enable = static_cast<u32>(!has_float);
+            }
+        }
+        UpdateLogicOpEnable(regs);
+        UpdateDepthClampEnable(regs);
+        UpdateLineRasterizationMode(regs);
+        UpdateLineStippleEnable(regs);
+        UpdateConservativeRasterizationMode(regs);
+        UpdateAlphaToCoverageEnable(regs);
+        UpdateAlphaToOneEnable(regs);
+    }
+    
+    // EDS3 Blending: ColorBlendEnable, ColorBlendEquation, ColorWriteMask
+    if (device.IsExtExtendedDynamicState3BlendingSupported()) {
+        UpdateBlending(regs);
+    }
+    
+    // Vertex Input Dynamic State: Independent from EDS levels
     if (device.IsExtVertexInputDynamicStateSupported()) {
         if (auto* gp = pipeline_cache.CurrentGraphicsPipeline(); gp && gp->HasDynamicVertexInput()) {
             UpdateVertexInput(regs);
@@ -984,9 +1066,16 @@ void RasterizerVulkan::HandleTransformFeedback() {
 
     const auto& regs = maxwell3d->regs;
     if (!device.IsExtTransformFeedbackSupported()) {
-        std::call_once(warn_unsupported, [&] {
-            LOG_ERROR(Render_Vulkan, "Transform feedbacks used but not supported");
-        });
+        // If the guest enabled transform feedback, warn once that the device lacks support.
+        if (regs.transform_feedback_enabled != 0) {
+            std::call_once(warn_unsupported, [&] {
+                LOG_WARNING(Render_Vulkan, "Transform feedback requested by guest but VK_EXT_transform_feedback is unavailable; queries disabled");
+            });
+        } else {
+            std::call_once(warn_unsupported, [&] {
+                LOG_INFO(Render_Vulkan, "VK_EXT_transform_feedback not available on device");
+            });
+        }
         return;
     }
     query_cache.CounterEnable(VideoCommon::QueryType::StreamingByteCount,
@@ -995,7 +1084,7 @@ void RasterizerVulkan::HandleTransformFeedback() {
         UNIMPLEMENTED_IF(regs.IsShaderConfigEnabled(Maxwell::ShaderType::TessellationInit) ||
                          regs.IsShaderConfigEnabled(Maxwell::ShaderType::Tessellation));
     }
-}
+} 
 
 void RasterizerVulkan::UpdateViewportsState(Tegra::Engines::Maxwell3D::Regs& regs) {
     if (!state_tracker.TouchViewports()) {
@@ -1144,6 +1233,9 @@ void RasterizerVulkan::UpdateBlendConstants(Tegra::Engines::Maxwell3D::Regs& reg
     if (!state_tracker.TouchBlendConstants()) {
         return;
     }
+    if (!device.UsesAdvancedCoreDynamicState()) {
+        return;
+    }
     const std::array blend_color = {regs.blend_color.r, regs.blend_color.g, regs.blend_color.b,
                                     regs.blend_color.a};
     scheduler.Record(
@@ -1154,6 +1246,9 @@ void RasterizerVulkan::UpdateDepthBounds(Tegra::Engines::Maxwell3D::Regs& regs)
     if (!state_tracker.TouchDepthBounds()) {
         return;
     }
+    if (!device.UsesAdvancedCoreDynamicState() || !device.IsDepthBoundsSupported()) {
+        return;
+    }
     scheduler.Record([min = regs.depth_bounds[0], max = regs.depth_bounds[1]](
                          vk::CommandBuffer cmdbuf) { cmdbuf.SetDepthBounds(min, max); });
 }
@@ -1162,6 +1257,10 @@ void RasterizerVulkan::UpdateStencilFaces(Tegra::Engines::Maxwell3D::Regs& regs)
     if (!state_tracker.TouchStencilProperties()) {
         return;
     }
+    if (!device.UsesAdvancedCoreDynamicState()) {
+        state_tracker.ClearStencilReset();
+        return;
+    }
     bool update_references = state_tracker.TouchStencilReference();
     bool update_write_mask = state_tracker.TouchStencilWriteMask();
     bool update_compare_masks = state_tracker.TouchStencilCompare();
@@ -1324,6 +1423,10 @@ void RasterizerVulkan::UpdateConservativeRasterizationMode(Tegra::Engines::Maxwe
         return;
     }
 
+    if (!device.SupportsDynamicState3ConservativeRasterizationMode()) {
+        return;
+    }
+
     scheduler.Record([enable = regs.conservative_raster_enable](vk::CommandBuffer cmdbuf) {
         cmdbuf.SetConservativeRasterizationModeEXT(
             enable ? VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT
@@ -1336,23 +1439,50 @@ void RasterizerVulkan::UpdateLineStippleEnable(Tegra::Engines::Maxwell3D::Regs&
         return;
     }
 
+    if (!device.SupportsDynamicState3LineStippleEnable()) {
+        return;
+    }
+
     scheduler.Record([enable = regs.line_stipple_enable](vk::CommandBuffer cmdbuf) {
         cmdbuf.SetLineStippleEnableEXT(enable);
     });
 }
 
 void RasterizerVulkan::UpdateLineRasterizationMode(Tegra::Engines::Maxwell3D::Regs& regs) {
-    // if (!state_tracker.TouchLi()) {
-    //     return;
-    // }
+    if (!device.IsExtLineRasterizationSupported()) {
+        return;
+    }
+    if (!state_tracker.TouchLineRasterizationMode()) {
+        return;
+    }
 
-    // TODO: The maxwell emulator does not capture line rasters
+    if (!device.SupportsDynamicState3LineRasterizationMode()) {
+        static std::once_flag warn_missing_rect;
+        std::call_once(warn_missing_rect, [] {
+            LOG_WARNING(Render_Vulkan,
+                        "Driver lacks rectangular line rasterization support; skipping dynamic "
+                        "line state updates");
+        });
+        return;
+    }
 
-    // scheduler.Record([enable = regs.line](vk::CommandBuffer cmdbuf) {
-    //     cmdbuf.SetConservativeRasterizationModeEXT(
-    //         enable ? VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT
-    //                : VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT);
-    // });
+    const bool wants_smooth = regs.line_anti_alias_enable != 0;
+    VkLineRasterizationModeEXT mode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT;
+    if (wants_smooth) {
+        if (device.SupportsSmoothLines()) {
+            mode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT;
+        } else {
+            static std::once_flag warn_missing_smooth;
+            std::call_once(warn_missing_smooth, [] {
+                LOG_WARNING(Render_Vulkan,
+                            "Line anti-aliasing requested but smoothLines feature unavailable; "
+                            "using rectangular rasterization");
+            });
+        }
+    }
+    scheduler.Record([mode](vk::CommandBuffer cmdbuf) {
+        cmdbuf.SetLineRasterizationModeEXT(mode);
+    });
 }
 
 void RasterizerVulkan::UpdateDepthBiasEnable(Tegra::Engines::Maxwell3D::Regs& regs) {
@@ -1394,6 +1524,9 @@ void RasterizerVulkan::UpdateLogicOpEnable(Tegra::Engines::Maxwell3D::Regs& regs
     if (!state_tracker.TouchLogicOpEnable()) {
         return;
     }
+    if (!device.SupportsDynamicState3LogicOpEnable()) {
+        return;
+    }
     scheduler.Record([enable = regs.logic_op.enable](vk::CommandBuffer cmdbuf) {
         cmdbuf.SetLogicOpEnableEXT(enable != 0);
     });
@@ -1403,6 +1536,9 @@ void RasterizerVulkan::UpdateDepthClampEnable(Tegra::Engines::Maxwell3D::Regs& r
     if (!state_tracker.TouchDepthClampEnable()) {
         return;
     }
+    if (!device.SupportsDynamicState3DepthClampEnable()) {
+        return;
+    }
     bool is_enabled = !(regs.viewport_clip_control.geometry_clip ==
                             Maxwell::ViewportClipControl::GeometryClip::Passthrough ||
                         regs.viewport_clip_control.geometry_clip ==
@@ -1413,6 +1549,41 @@ void RasterizerVulkan::UpdateDepthClampEnable(Tegra::Engines::Maxwell3D::Regs& r
         [is_enabled](vk::CommandBuffer cmdbuf) { cmdbuf.SetDepthClampEnableEXT(is_enabled); });
 }
 
+void RasterizerVulkan::UpdateAlphaToCoverageEnable(Tegra::Engines::Maxwell3D::Regs& regs) {
+    if (!state_tracker.TouchAlphaToCoverageEnable()) {
+        return;
+    }
+    if (!device.SupportsDynamicState3AlphaToCoverageEnable()) {
+        return;
+    }
+    GraphicsPipeline* const pipeline = pipeline_cache.CurrentGraphicsPipeline();
+    const bool enable = pipeline != nullptr && pipeline->SupportsAlphaToCoverage() &&
+                        regs.anti_alias_alpha_control.alpha_to_coverage != 0;
+    scheduler.Record([enable](vk::CommandBuffer cmdbuf) {
+        cmdbuf.SetAlphaToCoverageEnableEXT(enable ? VK_TRUE : VK_FALSE);
+    });
+}
+
+void RasterizerVulkan::UpdateAlphaToOneEnable(Tegra::Engines::Maxwell3D::Regs& regs) {
+    if (!state_tracker.TouchAlphaToOneEnable()) {
+        return;
+    }
+    if (!device.SupportsDynamicState3AlphaToOneEnable()) {
+        static std::once_flag warn_alpha_to_one;
+        std::call_once(warn_alpha_to_one, [] {
+            LOG_WARNING(Render_Vulkan,
+                        "Alpha-to-one is not supported on this device; forcing it disabled");
+        });
+        return;
+    }
+    GraphicsPipeline* const pipeline = pipeline_cache.CurrentGraphicsPipeline();
+    const bool enable = pipeline != nullptr && pipeline->SupportsAlphaToOne() &&
+                        regs.anti_alias_alpha_control.alpha_to_one != 0;
+    scheduler.Record([enable](vk::CommandBuffer cmdbuf) {
+        cmdbuf.SetAlphaToOneEnableEXT(enable ? VK_TRUE : VK_FALSE);
+    });
+}
+
 void RasterizerVulkan::UpdateDepthCompareOp(Tegra::Engines::Maxwell3D::Regs& regs) {
     if (!state_tracker.TouchDepthCompareOp()) {
         return;

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -183,6 +183,8 @@ private:
     void UpdateDepthBiasEnable(Tegra::Engines::Maxwell3D::Regs& regs);
     void UpdateLogicOpEnable(Tegra::Engines::Maxwell3D::Regs& regs);
     void UpdateDepthClampEnable(Tegra::Engines::Maxwell3D::Regs& regs);
+    void UpdateAlphaToCoverageEnable(Tegra::Engines::Maxwell3D::Regs& regs);
+    void UpdateAlphaToOneEnable(Tegra::Engines::Maxwell3D::Regs& regs);
     void UpdateFrontFace(Tegra::Engines::Maxwell3D::Regs& regs);
     void UpdateStencilOp(Tegra::Engines::Maxwell3D::Regs& regs);
     void UpdateStencilTestEnable(Tegra::Engines::Maxwell3D::Regs& regs);

src/video_core/renderer_vulkan/vk_scheduler.cpp

@@ -13,6 +13,7 @@
 
 #include "common/thread.h"
 #include "video_core/renderer_vulkan/vk_command_pool.h"
+#include "video_core/renderer_vulkan/vk_graphics_pipeline.h"
 #include "video_core/renderer_vulkan/vk_master_semaphore.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_state_tracker.h"
@@ -130,9 +131,27 @@ void Scheduler::RequestOutsideRenderPassOperationContext() {
 
 bool Scheduler::UpdateGraphicsPipeline(GraphicsPipeline* pipeline) {
     if (state.graphics_pipeline == pipeline) {
+        if (pipeline && pipeline->UsesExtendedDynamicState() &&
+            state.needs_state_enable_refresh) {
+            state_tracker.InvalidateStateEnableFlag();
+            state.needs_state_enable_refresh = false;
+        }
         return false;
     }
+
     state.graphics_pipeline = pipeline;
+
+    if (!pipeline) {
+        return true;
+    }
+
+    if (!pipeline->UsesExtendedDynamicState()) {
+        state.needs_state_enable_refresh = true;
+    } else if (state.needs_state_enable_refresh) {
+        state_tracker.InvalidateStateEnableFlag();
+        state.needs_state_enable_refresh = false;
+    }
+
     return true;
 }
 
@@ -277,6 +296,7 @@ void Scheduler::EndRenderPass()
         }
 
         query_cache->CounterEnable(VideoCommon::QueryType::ZPassPixelCount64, false);
+        query_cache->CounterEnable(VideoCommon::QueryType::StreamingByteCount, false);
         query_cache->NotifySegment(false);
 
         Record([num_images = num_renderpass_images,

src/video_core/renderer_vulkan/vk_scheduler.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -214,6 +217,7 @@ private:
         GraphicsPipeline* graphics_pipeline = nullptr;
         bool is_rescaling = false;
         bool rescaling_defined = false;
+        bool needs_state_enable_refresh = false;
     };
 
     void WorkerThread(std::stop_token stop_token);

src/video_core/renderer_vulkan/vk_state_tracker.cpp

@@ -48,6 +48,7 @@ Flags MakeInvalidationFlags() {
         FrontFace,
         StencilOp,
         StencilTestEnable,
+        RasterizerDiscardEnable,
         VertexBuffers,
         VertexInput,
         StateEnable,
@@ -55,6 +56,9 @@ Flags MakeInvalidationFlags() {
         DepthBiasEnable,
         LogicOpEnable,
         DepthClampEnable,
+        AlphaToCoverageEnable,
+        AlphaToOneEnable,
+        LineRasterizationMode,
         LogicOp,
         Blending,
         ColorMask,
@@ -148,6 +152,8 @@ void SetupDirtyStateEnable(Tables& tables) {
     setup(OFF(logic_op.enable), LogicOpEnable);
     setup(OFF(viewport_clip_control.geometry_clip), DepthClampEnable);
     setup(OFF(line_stipple_enable), LineStippleEnable);
+    setup(OFF(anti_alias_alpha_control.alpha_to_coverage), AlphaToCoverageEnable);
+    setup(OFF(anti_alias_alpha_control.alpha_to_one), AlphaToOneEnable);
 }
 
 void SetupDirtyDepthCompareOp(Tables& tables) {
@@ -226,6 +232,7 @@ void SetupRasterModes(Tables &tables) {
 
     table[OFF(line_stipple_params)] = LineStippleParams;
     table[OFF(conservative_raster_enable)] = ConservativeRasterizationMode;
+    table[OFF(line_anti_alias_enable)] = LineRasterizationMode;
 }
 } // Anonymous namespace
 

src/video_core/renderer_vulkan/vk_state_tracker.h

@@ -54,6 +54,7 @@ enum : u8 {
     PrimitiveRestartEnable,
     RasterizerDiscardEnable,
     ConservativeRasterizationMode,
+    LineRasterizationMode,
     LineStippleEnable,
     LineStippleParams,
     DepthBiasEnable,
@@ -61,6 +62,8 @@ enum : u8 {
     LogicOp,
     LogicOpEnable,
     DepthClampEnable,
+    AlphaToCoverageEnable,
+    AlphaToOneEnable,
 
     Blending,
     BlendEnable,
@@ -94,6 +97,10 @@ public:
         (*flags)[Dirty::Scissors] = true;
     }
 
+    void InvalidateStateEnableFlag() {
+        (*flags)[Dirty::StateEnable] = true;
+    }
+
     bool TouchViewports() {
         const bool dirty_viewports = Exchange(Dirty::Viewports, false);
         const bool rescale_viewports = Exchange(VideoCommon::Dirty::RescaleViewports, false);
@@ -225,6 +232,14 @@ public:
         return Exchange(Dirty::DepthClampEnable, false);
     }
 
+    bool TouchAlphaToCoverageEnable() {
+        return Exchange(Dirty::AlphaToCoverageEnable, false);
+    }
+
+    bool TouchAlphaToOneEnable() {
+        return Exchange(Dirty::AlphaToOneEnable, false);
+    }
+
     bool TouchDepthCompareOp() {
         return Exchange(Dirty::DepthCompareOp, false);
     }
@@ -261,6 +276,10 @@ public:
         return Exchange(Dirty::LogicOp, false);
     }
 
+    bool TouchLineRasterizationMode() {
+        return Exchange(Dirty::LineRasterizationMode, false);
+    }
+
     bool ChangePrimitiveTopology(Maxwell::PrimitiveTopology new_topology) {
         const bool has_changed = current_topology != new_topology;
         current_topology = new_topology;

src/video_core/renderer_vulkan/vk_swapchain.cpp

@@ -306,7 +306,17 @@ void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities) {
         swapchain_ci.queueFamilyIndexCount = static_cast<u32>(queue_indices.size());
         swapchain_ci.pQueueFamilyIndices = queue_indices.data();
     }
-    static constexpr std::array view_formats{VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_B8G8R8A8_SRGB};
+    // According to Vulkan spec, when using VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR,
+    // the base format (imageFormat) MUST be included in pViewFormats
+    const std::array view_formats{
+        swapchain_ci.imageFormat,  // Base format MUST be first
+        VK_FORMAT_B8G8R8A8_UNORM,
+        VK_FORMAT_B8G8R8A8_SRGB,
+#ifdef ANDROID
+        VK_FORMAT_R8G8B8A8_UNORM,  // Android may use RGBA
+        VK_FORMAT_R8G8B8A8_SRGB,
+#endif
+    };
     VkImageFormatListCreateInfo format_list{
         .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR,
         .pNext = nullptr,

src/video_core/renderer_vulkan/vk_swapchain.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -101,7 +104,7 @@ public:
     }
 
     VkSemaphore CurrentRenderSemaphore() const {
-        return *render_semaphores[frame_index];
+        return *render_semaphores[image_index];
     }
 
     u32 GetWidth() const {

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -1104,6 +1104,8 @@ void TextureCacheRuntime::BlitImage(Framebuffer* dst_framebuffer, ImageView& dst
                 UNREACHABLE();
             }
         }();
+        // Use shader-based depth/stencil blits if hardware doesn't support the format
+        // Note: MSAA resolves (MSAA->single) use vkCmdResolveImage which works fine
         if (!can_blit_depth_stencil) {
             UNIMPLEMENTED_IF(is_src_msaa || is_dst_msaa);
             blit_image_helper.BlitDepthStencil(dst_framebuffer, src, dst_region, src_region,
@@ -1118,6 +1120,15 @@ void TextureCacheRuntime::BlitImage(Framebuffer* dst_framebuffer, ImageView& dst
     const VkImage src_image = src.ImageHandle();
     const VkImageSubresourceLayers dst_layers = MakeSubresourceLayers(&dst);
     const VkImageSubresourceLayers src_layers = MakeSubresourceLayers(&src);
+    const bool is_msaa_to_msaa = is_src_msaa && is_dst_msaa;
+    
+    // NVIDIA 510+ and Intel crash on MSAA->MSAA blits (scaling operations)
+    // Fall back to 3D helpers for MSAA scaling
+    if (is_msaa_to_msaa && device.CantBlitMSAA()) {
+        // This should be handled by NeedsScaleHelper() and use 3D helpers instead
+        UNIMPLEMENTED_MSG("MSAA to MSAA blit not supported on this driver");
+        return;
+    }
     const bool is_resolve = is_src_msaa && !is_dst_msaa;
     scheduler.RequestOutsideRenderPassOperationContext();
     scheduler.Record([filter, dst_region, src_region, dst_image, src_image, dst_layers, src_layers,
@@ -2222,18 +2233,26 @@ vk::ImageView ImageView::MakeView(VkFormat vk_format, VkImageAspectFlags aspect_
 
 Sampler::Sampler(TextureCacheRuntime& runtime, const Tegra::Texture::TSCEntry& tsc) {
     const auto& device = runtime.device;
-    const bool arbitrary_borders = runtime.device.IsExtCustomBorderColorSupported();
+    // Check if custom border colors are supported
+    const bool has_custom_border_colors = runtime.device.IsCustomBorderColorsSupported();
+    const bool has_format_undefined = runtime.device.IsCustomBorderColorWithoutFormatSupported();
     const auto color = tsc.BorderColor();
 
+    // Determine border format based on available features:
+    // - If customBorderColorWithoutFormat is available: use VK_FORMAT_UNDEFINED (most flexible)
+    // - If only customBorderColors is available: use concrete format (R8G8B8A8_UNORM)
+    // - If neither is available: use standard border colors (handled by ConvertBorderColor)
+    const VkFormat border_format = has_format_undefined ? VK_FORMAT_UNDEFINED
+                                                        : VK_FORMAT_R8G8B8A8_UNORM;
+
     const VkSamplerCustomBorderColorCreateInfoEXT border_ci{
         .sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT,
         .pNext = nullptr,
-        // TODO: Make use of std::bit_cast once libc++ supports it.
         .customBorderColor = std::bit_cast<VkClearColorValue>(color),
-        .format = VK_FORMAT_UNDEFINED,
+        .format = border_format,
     };
     const void* pnext = nullptr;
-    if (arbitrary_borders) {
+    if (has_custom_border_colors) {
         pnext = &border_ci;
     }
     const VkSamplerReductionModeCreateInfoEXT reduction_ci{
@@ -2267,8 +2286,8 @@ Sampler::Sampler(TextureCacheRuntime& runtime, const Tegra::Texture::TSCEntry& t
             .compareOp = MaxwellToVK::Sampler::DepthCompareFunction(tsc.depth_compare_func),
             .minLod = tsc.mipmap_filter == TextureMipmapFilter::None ? 0.0f : tsc.MinLod(),
             .maxLod = tsc.mipmap_filter == TextureMipmapFilter::None ? 0.25f : tsc.MaxLod(),
-            .borderColor =
-                arbitrary_borders ? VK_BORDER_COLOR_FLOAT_CUSTOM_EXT : ConvertBorderColor(color),
+            .borderColor = has_custom_border_colors ? VK_BORDER_COLOR_FLOAT_CUSTOM_EXT
+                                                    : ConvertBorderColor(color),
             .unnormalizedCoordinates = VK_FALSE,
         });
     };

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -241,7 +244,6 @@ public:
     [[nodiscard]] VkImageView Handle(Shader::TextureType texture_type) const noexcept {
         return *image_views[static_cast<size_t>(texture_type)];
     }
-
     [[nodiscard]] VkImage ImageHandle() const noexcept {
         return image_handle;
     }

src/video_core/texture_cache/image_info.cpp

@@ -33,6 +33,7 @@ ImageInfo::ImageInfo(const TICEntry& config) noexcept {
     dma_downloaded = forced_flushed;
     format = PixelFormatFromTextureInfo(config.format, config.r_type, config.g_type, config.b_type,
                                         config.a_type, config.srgb_conversion);
+    
     num_samples = NumSamples(config.msaa_mode);
     resources.levels = config.max_mip_level + 1;
     if (config.IsPitchLinear()) {

src/video_core/vulkan_common/vulkan.h

@@ -15,8 +15,6 @@
 #define VK_USE_PLATFORM_ANDROID_KHR
 #elif defined(__HAIKU__)
 #define VK_USE_PLATFORM_XCB_KHR
-#elif defined(__OPENORBIS__)
-// No fucking vulkan on the PlayStation 4
 #else
 #define VK_USE_PLATFORM_XLIB_KHR
 #define VK_USE_PLATFORM_WAYLAND_KHR
@@ -24,6 +22,17 @@
 
 #include <vulkan/vulkan.h>
 
+// Define maintenance 7-9 extension names (not yet in official Vulkan headers)
+#ifndef VK_KHR_MAINTENANCE_7_EXTENSION_NAME
+#define VK_KHR_MAINTENANCE_7_EXTENSION_NAME "VK_KHR_maintenance7"
+#endif
+#ifndef VK_KHR_MAINTENANCE_8_EXTENSION_NAME
+#define VK_KHR_MAINTENANCE_8_EXTENSION_NAME "VK_KHR_maintenance8"
+#endif
+#ifndef VK_KHR_MAINTENANCE_9_EXTENSION_NAME
+#define VK_KHR_MAINTENANCE_9_EXTENSION_NAME "VK_KHR_maintenance9"
+#endif
+
 // Sanitize macros
 #undef CreateEvent
 #undef CreateSemaphore

src/video_core/vulkan_common/vulkan_device.cpp

@@ -292,9 +292,10 @@ std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(vk::Physica
 #if defined(ANDROID) && defined(ARCHITECTURE_arm64)
 void OverrideBcnFormats(std::unordered_map<VkFormat, VkFormatProperties>& format_properties) {
     // These properties are extracted from Adreno driver 512.687.0
-    constexpr VkFormatFeatureFlags tiling_features{
-                                                   VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT |
-                                                   VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
+    constexpr VkFormatFeatureFlags tiling_features{VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
+                                                   VK_FORMAT_FEATURE_BLIT_SRC_BIT |
+                                                   VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT |
+                                                   VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
                                                    VK_FORMAT_FEATURE_TRANSFER_DST_BIT};
 
     constexpr VkFormatFeatureFlags buffer_features{VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT};
@@ -416,7 +417,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     const bool is_suitable = GetSuitability(surface != nullptr);
 
     const VkDriverId driver_id = properties.driver.driverID;
-    const auto device_id = properties.properties.deviceID;
     const bool is_radv = driver_id == VK_DRIVER_ID_MESA_RADV;
     const bool is_amd_driver =
         driver_id == VK_DRIVER_ID_AMD_PROPRIETARY || driver_id == VK_DRIVER_ID_AMD_OPEN_SOURCE;
@@ -427,11 +427,13 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     const bool is_mvk = driver_id == VK_DRIVER_ID_MOLTENVK;
     const bool is_qualcomm = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY;
     const bool is_turnip = driver_id == VK_DRIVER_ID_MESA_TURNIP;
-    const bool is_s8gen2 = device_id == 0x43050a01;
-    //const bool is_arm = driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
+    const bool is_arm = driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
 
-    if (!is_suitable)
-        LOG_WARNING(Render_Vulkan, "Unsuitable driver - continuing anyways");
+    if ((is_mvk || is_qualcomm || is_turnip || is_arm) && !is_suitable) {
+        LOG_WARNING(Render_Vulkan, "Unsuitable driver, continuing anyway");
+    } else if (!is_suitable) {
+        throw vk::Exception(VK_ERROR_INCOMPATIBLE_DRIVER);
+    }
 
     if (is_nvidia) {
         nvidia_arch = GetNvidiaArchitecture(physical, supported_extensions);
@@ -492,6 +494,11 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     CollectToolingInfo();
 
     if (is_qualcomm) {
+        // Qualcomm Adreno GPUs doesn't handle scaled vertex attributes; keep emulation enabled
+        must_emulate_scaled_formats = true;
+        LOG_WARNING(Render_Vulkan,
+                    "Qualcomm drivers require scaled vertex format emulation; forcing fallback");
+
         LOG_WARNING(Render_Vulkan,
                     "Disabling shader float controls and 64-bit integer features on Qualcomm proprietary drivers");
         RemoveExtension(extensions.shader_float_controls, VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME);
@@ -533,35 +540,31 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         }
 
         if (nv_major_version >= 510) {
-            LOG_WARNING(Render_Vulkan, "NVIDIA Drivers >= 510 do not support MSAA image blits");
+            LOG_WARNING(Render_Vulkan, 
+                        "NVIDIA Drivers >= 510 do not support MSAA->MSAA image blits. "
+                        "MSAA scaling will use 3D helpers. MSAA resolves work normally.");
             cant_blit_msaa = true;
         }
-    }
 
-    if (extensions.extended_dynamic_state3 && is_radv) {
-        LOG_WARNING(Render_Vulkan, "RADV has broken extendedDynamicState3ColorBlendEquation");
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = false;
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = false;
-        dynamic_state3_blending = false;
-
-        const u32 version = (properties.properties.driverVersion << 3) >> 3;
-        if (version < VK_MAKE_API_VERSION(0, 23, 1, 0)) {
-            LOG_WARNING(Render_Vulkan,
-                        "RADV versions older than 23.1.0 have broken depth clamp dynamic state");
-            features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable = false;
-            dynamic_state3_enables = false;
+        // Mali/ NVIDIA proprietary drivers: Shader stencil export not supported
+        // Use hardware depth/stencil blits instead when available
+        if (!extensions.shader_stencil_export) {
+            LOG_INFO(Render_Vulkan,
+                     "NVIDIA: VK_EXT_shader_stencil_export not supported, using hardware blits "
+                     "for depth/stencil operations");
+            LOG_INFO(Render_Vulkan, "  D24S8 hardware blit support: {}",
+                     is_blit_depth24_stencil8_supported);
+            LOG_INFO(Render_Vulkan, "  D32S8 hardware blit support: {}",
+                     is_blit_depth32_stencil8_supported);
+            
+            if (!is_blit_depth24_stencil8_supported && !is_blit_depth32_stencil8_supported) {
+                LOG_WARNING(Render_Vulkan,
+                            "NVIDIA: Neither shader export nor hardware blits available for "
+                            "depth/stencil. Performance may be degraded.");
+            }
         }
     }
 
-    if (extensions.extended_dynamic_state3 && (is_amd_driver || driver_id == VK_DRIVER_ID_SAMSUNG_PROPRIETARY)) {
-        // AMD and Samsung drivers have broken extendedDynamicState3ColorBlendEquation
-        LOG_WARNING(Render_Vulkan,
-                    "AMD and Samsung drivers have broken extendedDynamicState3ColorBlendEquation");
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = false;
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = false;
-        dynamic_state3_blending = false;
-    }
-
     sets_per_pool = 64;
     if (is_amd_driver) {
         // AMD drivers need a higher amount of Sets per Pool in certain circumstances like in XC2.
@@ -598,15 +601,27 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     }
 
     if (is_intel_windows) {
-        LOG_WARNING(Render_Vulkan, "Intel proprietary drivers do not support MSAA image blits");
+        LOG_WARNING(Render_Vulkan, 
+                    "Intel proprietary drivers do not support MSAA->MSAA image blits. "
+                    "MSAA scaling will use 3D helpers. MSAA resolves work normally.");
         cant_blit_msaa = true;
     }
 
     has_broken_compute =
         CheckBrokenCompute(properties.driver.driverID, properties.properties.driverVersion) &&
         !Settings::values.enable_compute_pipelines.GetValue();
-    if (is_intel_anv || (is_qualcomm && !is_s8gen2)) {
-        LOG_WARNING(Render_Vulkan, "Driver does not support native BGR format");
+    must_emulate_bgr565 = false; // Default: assume emulation isn't required
+
+    if (is_intel_anv) {
+        LOG_WARNING(Render_Vulkan, "Intel ANV driver does not support native BGR format");
+        must_emulate_bgr565 = true;
+    } else if (is_qualcomm) {
+        LOG_WARNING(Render_Vulkan,
+                    "Qualcomm driver mishandles BGR5 formats even with VK_KHR_maintenance5, forcing emulation");
+        must_emulate_bgr565 = true;
+    } else if (is_arm) {
+        LOG_WARNING(Render_Vulkan,
+                    "ARM Mali driver mishandles BGR5 formats even with VK_KHR_maintenance5, forcing emulation");
         must_emulate_bgr565 = true;
     }
 
@@ -619,51 +634,55 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             (std::min)(properties.properties.limits.maxVertexInputBindings, 16U);
     }
 
-    if (is_turnip) {
-        LOG_WARNING(Render_Vulkan, "Turnip requires higher-than-reported binding limits");
+    if (is_turnip || is_qualcomm) {
+        LOG_WARNING(Render_Vulkan, "Driver requires higher-than-reported binding limits");
         properties.properties.limits.maxVertexInputBindings = 32;
     }
 
-    if (!extensions.extended_dynamic_state && extensions.extended_dynamic_state2) {
-        LOG_INFO(Render_Vulkan,
-                 "Removing extendedDynamicState2 due to missing extendedDynamicState");
-        RemoveExtensionFeature(extensions.extended_dynamic_state2, features.extended_dynamic_state2,
-                               VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
-    }
-
-    if (!extensions.extended_dynamic_state2 && extensions.extended_dynamic_state3) {
-        LOG_INFO(Render_Vulkan,
-                 "Removing extendedDynamicState3 due to missing extendedDynamicState2");
-        RemoveExtensionFeature(extensions.extended_dynamic_state3, features.extended_dynamic_state3,
-                               VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
-        dynamic_state3_blending = false;
-        dynamic_state3_enables = false;
-    }
-
-    // Mesa Intel drivers on UHD 620 have broken EDS causing extreme flickering - unknown if it affects other iGPUs
-    // ALSO affects ALL versions of UHD drivers on Windows 10+, seems to cause even worse issues like straight up crashing
-    // So... Yeah, UHD drivers fucking suck -- maybe one day we can work past this, maybe; some driver hacking?
-    // And then we can rest in peace by doing `< VK_MAKE_API_VERSION(26, 0, 0)` for our beloved mesa drivers... one day
-    if ((is_mvk || (is_integrated && is_intel_anv) || (is_integrated && is_intel_windows)) && Settings::values.dyna_state.GetValue() != 0) {
-        LOG_WARNING(Render_Vulkan, "Driver has broken dynamic state, forcing to 0 to prevent graphical issues");
-        Settings::values.dyna_state.SetValue(0);
-    }
-
+    // Base dynamic states (VIEWPORT, SCISSOR, DEPTH_BIAS, etc.) are ALWAYS active in vk_graphics_pipeline.cpp
+    // This slider controls EXTENDED dynamic states with accumulative levels per Vulkan specs:
+    //   Level 0 = Core Dynamic States only (Vulkan 1.0)
+    //   Level 1 = Core + VK_EXT_extended_dynamic_state
+    //   Level 2 = Core + VK_EXT_extended_dynamic_state + VK_EXT_extended_dynamic_state2
+    //   Level 3 = Core + VK_EXT_extended_dynamic_state + VK_EXT_extended_dynamic_state2 + VK_EXT_extended_dynamic_state3
+    
     switch (Settings::values.dyna_state.GetValue()) {
     case 0:
-        RemoveExtensionFeature(extensions.extended_dynamic_state, features.extended_dynamic_state, VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
-        [[fallthrough]];
-    case 1:
-        RemoveExtensionFeature(extensions.extended_dynamic_state2, features.extended_dynamic_state2, VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
-        [[fallthrough]];
-    case 2:
-        RemoveExtensionFeature(extensions.extended_dynamic_state3, features.extended_dynamic_state3, VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
+        // Level 0: Disable all extended dynamic state extensions
+        RemoveExtensionFeature(extensions.extended_dynamic_state, features.extended_dynamic_state, 
+                              VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
+        RemoveExtensionFeature(extensions.extended_dynamic_state2, features.extended_dynamic_state2, 
+                              VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
+        RemoveExtensionFeature(extensions.extended_dynamic_state3, features.extended_dynamic_state3, 
+                              VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
         dynamic_state3_blending = false;
         dynamic_state3_enables = false;
         break;
+    case 1:
+        // Level 1: Enable EDS1, disable EDS2 and EDS3
+        RemoveExtensionFeature(extensions.extended_dynamic_state2, features.extended_dynamic_state2, 
+                              VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
+        RemoveExtensionFeature(extensions.extended_dynamic_state3, features.extended_dynamic_state3, 
+                              VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
+        dynamic_state3_blending = false;
+        dynamic_state3_enables = false;
+        break;
+    case 2:
+        // Level 2: Enable EDS1 + EDS2, disable EDS3
+        RemoveExtensionFeature(extensions.extended_dynamic_state3, features.extended_dynamic_state3, 
+                              VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
+        dynamic_state3_blending = false;
+        dynamic_state3_enables = false;
+        break;
+    case 3:
+    default:
+        // Level 3: Enable all (EDS1 + EDS2 + EDS3)
+        break;
     }
 
-    if (!Settings::values.vertex_input_dynamic_state.GetValue() || !extensions.extended_dynamic_state) {
+    // VK_EXT_vertex_input_dynamic_state is independent from EDS
+    // It can be enabled even without extended_dynamic_state
+    if (!Settings::values.vertex_input_dynamic_state.GetValue()) {
         RemoveExtensionFeature(extensions.vertex_input_dynamic_state, features.vertex_input_dynamic_state, VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
     }
 
@@ -751,8 +770,8 @@ void Device::SaveShader(std::span<const u32> spirv) const {
 }
 
 bool Device::ComputeIsOptimalAstcSupported() const {
-    // Disable for now to avoid converting ASTC twice.
-    static constexpr std::array astc_formats = {
+    // Verify hardware supports all ASTC formats with optimal tiling to avoid software conversion
+    static constexpr std::array<VkFormat, 28> astc_formats = {
         VK_FORMAT_ASTC_4x4_UNORM_BLOCK,   VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
         VK_FORMAT_ASTC_5x4_UNORM_BLOCK,   VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
         VK_FORMAT_ASTC_5x5_UNORM_BLOCK,   VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
@@ -771,9 +790,10 @@ bool Device::ComputeIsOptimalAstcSupported() const {
     if (!features.features.textureCompressionASTC_LDR) {
         return false;
     }
-    const auto format_feature_usage{
-                                    VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT |
-                                    VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
+    const auto format_feature_usage{VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
+                                    VK_FORMAT_FEATURE_BLIT_SRC_BIT |
+                                    VK_FORMAT_FEATURE_BLIT_DST_BIT |
+                                    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
                                     VK_FORMAT_FEATURE_TRANSFER_DST_BIT};
     for (const auto format : astc_formats) {
         const auto physical_format_properties{physical.GetFormatProperties(format)};
@@ -970,7 +990,7 @@ bool Device::GetSuitability(bool requires_swapchain) {
     // Set next pointer.
     void** next = &features2.pNext;
 
-    // Vulkan 1.2, 1.3 and 1.4 features
+    // Vulkan 1.2 and 1.3 features
     if (instance_version >= VK_API_VERSION_1_2) {
         features_1_2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
         features_1_3.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
@@ -1076,6 +1096,16 @@ bool Device::GetSuitability(bool requires_swapchain) {
             VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
         SetNext(next, properties.transform_feedback);
     }
+    if (extensions.maintenance5) {
+        properties.maintenance5.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR;
+        SetNext(next, properties.maintenance5);
+    }
+    if (extensions.multi_draw) {
+        properties.multi_draw.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
+        SetNext(next, properties.multi_draw);
+    }
 
     // Perform the property fetch.
     physical.GetProperties2(properties2);
@@ -1108,14 +1138,75 @@ bool Device::GetSuitability(bool requires_swapchain) {
         }
     }
 
+    // VK_DYNAMIC_STATE
+    
+    // Driver detection variables for workarounds in GetSuitability
+    const VkDriverId driver_id = properties.driver.driverID;
+    [[maybe_unused]] const bool is_amd_driver =
+        driver_id == VK_DRIVER_ID_AMD_PROPRIETARY || driver_id == VK_DRIVER_ID_AMD_OPEN_SOURCE;
+    const bool is_intel_windows = driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS;
+    [[maybe_unused]] const bool is_qualcomm = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY;
+    
+    // VK_EXT_extended_dynamic_state2 below this will appear drivers that need workarounds.
+    
+    // VK_EXT_extended_dynamic_state3 below this will appear drivers that need workarounds.
+    
+    [[maybe_unused]] const auto device_id = properties.properties.deviceID;
+    
+    // Samsung: Broken extendedDynamicState3ColorBlendEquation
+    // Disable blend equation dynamic state, force static pipeline state
+    if (extensions.extended_dynamic_state3 && 
+        (driver_id == VK_DRIVER_ID_SAMSUNG_PROPRIETARY)) {
+        LOG_WARNING(Render_Vulkan,
+                    "Samsung: Disabling broken extendedDynamicState3ColorBlendEquation");
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = false;
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = false;
+    }
+    
+    // Intel Windows < 27.20.100.0: Broken VertexInputDynamicState
+    // Disable VertexInputDynamicState on old Intel Windows drivers
+    if (extensions.vertex_input_dynamic_state && is_intel_windows) {
+        const u32 version = (properties.properties.driverVersion << 3) >> 3;
+        if (version < VK_MAKE_API_VERSION(27, 20, 100, 0)) {
+            LOG_WARNING(Render_Vulkan,
+                        "Intel Windows < 27.20.100.0: Disabling broken VK_EXT_vertex_input_dynamic_state");
+            RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
+                                   features.vertex_input_dynamic_state,
+                                   VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+        }
+    }
+    
+    if (Settings::values.dyna_state.GetValue() == 0) {
+        LOG_INFO(Render_Vulkan, "Extended Dynamic State disabled by user setting, clearing all EDS features");
+        features.custom_border_color.customBorderColors = false;
+        features.custom_border_color.customBorderColorWithoutFormat = false;
+        features.extended_dynamic_state.extendedDynamicState = false;
+        features.extended_dynamic_state2.extendedDynamicState2 = false;
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = false;
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = false;
+        features.extended_dynamic_state3.extendedDynamicState3ColorWriteMask = false;
+        features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable = false;
+        features.extended_dynamic_state3.extendedDynamicState3LogicOpEnable = false;
+    }
+
     // Return whether we were suitable.
     return suitable;
 }
 
 void Device::RemoveUnsuitableExtensions() {
     // VK_EXT_custom_border_color
-    extensions.custom_border_color = features.custom_border_color.customBorderColors &&
-                                     features.custom_border_color.customBorderColorWithoutFormat;
+    // Enable extension if driver supports it, then check individual features
+    // - customBorderColors: Required to use VK_BORDER_COLOR_FLOAT_CUSTOM_EXT
+    // - customBorderColorWithoutFormat: Optional, allows VK_FORMAT_UNDEFINED
+    // If only customBorderColors is available, we must provide a specific format
+    if (extensions.custom_border_color) {
+        // Verify that at least customBorderColors is available
+        if (!features.custom_border_color.customBorderColors) {
+            LOG_WARNING(Render_Vulkan,
+                        "VK_EXT_custom_border_color reported but customBorderColors feature not available, disabling");
+            extensions.custom_border_color = false;
+        }
+    }
     RemoveExtensionFeatureIfUnsuitable(extensions.custom_border_color, features.custom_border_color,
                                        VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
 
@@ -1144,21 +1235,79 @@ void Device::RemoveUnsuitableExtensions() {
                                        VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
 
     // VK_EXT_extended_dynamic_state3
-    dynamic_state3_blending =
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable &&
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation &&
+    const bool supports_color_blend_enable =
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable;
+    const bool supports_color_blend_equation =
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation;
+    const bool supports_color_write_mask =
         features.extended_dynamic_state3.extendedDynamicState3ColorWriteMask;
-    dynamic_state3_enables =
-        features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable &&
+    dynamic_state3_blending = supports_color_blend_enable && supports_color_blend_equation &&
+                              supports_color_write_mask;
+
+    const bool supports_depth_clamp_enable =
+        features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable;
+    const bool supports_logic_op_enable =
         features.extended_dynamic_state3.extendedDynamicState3LogicOpEnable;
+    const bool supports_line_raster_mode =
+        features.extended_dynamic_state3.extendedDynamicState3LineRasterizationMode &&
+        extensions.line_rasterization && features.line_rasterization.rectangularLines;
+    const bool supports_conservative_raster_mode =
+        features.extended_dynamic_state3.extendedDynamicState3ConservativeRasterizationMode &&
+        extensions.conservative_rasterization;
+    const bool supports_line_stipple_enable =
+        features.extended_dynamic_state3.extendedDynamicState3LineStippleEnable &&
+        extensions.line_rasterization && features.line_rasterization.stippledRectangularLines;
+    const bool supports_alpha_to_coverage =
+        features.extended_dynamic_state3.extendedDynamicState3AlphaToCoverageEnable;
+    const bool supports_alpha_to_one =
+        features.extended_dynamic_state3.extendedDynamicState3AlphaToOneEnable &&
+        features.features.alphaToOne;
+
+    dynamic_state3_depth_clamp_enable = supports_depth_clamp_enable;
+    dynamic_state3_logic_op_enable = supports_logic_op_enable;
+    dynamic_state3_line_raster_mode = supports_line_raster_mode;
+    dynamic_state3_conservative_raster_mode = supports_conservative_raster_mode;
+    dynamic_state3_line_stipple_enable = supports_line_stipple_enable;
+    dynamic_state3_alpha_to_coverage = supports_alpha_to_coverage;
+    dynamic_state3_alpha_to_one = supports_alpha_to_one;
+
+    dynamic_state3_enables = dynamic_state3_depth_clamp_enable || dynamic_state3_logic_op_enable ||
+                             dynamic_state3_line_raster_mode ||
+                             dynamic_state3_conservative_raster_mode ||
+                             dynamic_state3_line_stipple_enable ||
+                             dynamic_state3_alpha_to_coverage || dynamic_state3_alpha_to_one;
 
     extensions.extended_dynamic_state3 = dynamic_state3_blending || dynamic_state3_enables;
-    dynamic_state3_blending = dynamic_state3_blending && extensions.extended_dynamic_state3;
-    dynamic_state3_enables = dynamic_state3_enables && extensions.extended_dynamic_state3;
+    if (!extensions.extended_dynamic_state3) {
+        dynamic_state3_blending = false;
+        dynamic_state3_enables = false;
+        dynamic_state3_depth_clamp_enable = false;
+        dynamic_state3_logic_op_enable = false;
+        dynamic_state3_line_raster_mode = false;
+        dynamic_state3_conservative_raster_mode = false;
+        dynamic_state3_line_stipple_enable = false;
+        dynamic_state3_alpha_to_coverage = false;
+        dynamic_state3_alpha_to_one = false;
+    }
     RemoveExtensionFeatureIfUnsuitable(extensions.extended_dynamic_state3,
                                        features.extended_dynamic_state3,
                                        VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
 
+    // VK_EXT_robustness2
+    // Enable if at least one robustness2 feature is available
+    extensions.robustness_2 = features.robustness2.robustBufferAccess2 ||
+                              features.robustness2.robustImageAccess2 ||
+                              features.robustness2.nullDescriptor;
+    
+    RemoveExtensionFeatureIfUnsuitable(extensions.robustness_2, features.robustness2,
+                                       VK_EXT_ROBUSTNESS_2_EXTENSION_NAME);
+
+    // VK_EXT_image_robustness
+    // Enable if robustImageAccess is available
+    extensions.image_robustness = features.image_robustness.robustImageAccess;
+    RemoveExtensionFeatureIfUnsuitable(extensions.image_robustness, features.image_robustness,
+                                       VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME);
+
     // VK_EXT_provoking_vertex
     if (Settings::values.provoking_vertex.GetValue()) {
         extensions.provoking_vertex = features.provoking_vertex.provokingVertexLast
@@ -1196,15 +1345,21 @@ void Device::RemoveUnsuitableExtensions() {
                                        VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME);
 
     // VK_EXT_transform_feedback
+    // We only require the basic transformFeedback feature and at least
+    // one transform feedback buffer. We keep transformFeedbackQueries as it's used by
+    // the streaming byte count implementation. GeometryStreams and multiple streams
+    // are not strictly required since we currently support only stream 0.
     extensions.transform_feedback =
         features.transform_feedback.transformFeedback &&
-        features.transform_feedback.geometryStreams &&
-        properties.transform_feedback.maxTransformFeedbackStreams >= 4 &&
         properties.transform_feedback.maxTransformFeedbackBuffers > 0 &&
-        properties.transform_feedback.transformFeedbackQueries &&
-        properties.transform_feedback.transformFeedbackDraw;
+        properties.transform_feedback.transformFeedbackQueries;
     RemoveExtensionFeatureIfUnsuitable(extensions.transform_feedback, features.transform_feedback,
                                        VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
+    if (extensions.transform_feedback) {
+        LOG_INFO(Render_Vulkan, "VK_EXT_transform_feedback enabled (buffers={}, queries={})",
+                 properties.transform_feedback.maxTransformFeedbackBuffers,
+                 properties.transform_feedback.transformFeedbackQueries);
+    }
 
     // VK_EXT_vertex_input_dynamic_state
     extensions.vertex_input_dynamic_state =
@@ -1213,6 +1368,17 @@ void Device::RemoveUnsuitableExtensions() {
                                        features.vertex_input_dynamic_state,
                                        VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
 
+    // VK_EXT_multi_draw
+    extensions.multi_draw = features.multi_draw.multiDraw;
+    
+    if (extensions.multi_draw) {
+        LOG_INFO(Render_Vulkan, "VK_EXT_multi_draw: maxMultiDrawCount={}",
+                 properties.multi_draw.maxMultiDrawCount);
+    }
+    
+    RemoveExtensionFeatureIfUnsuitable(extensions.multi_draw, features.multi_draw,
+                                       VK_EXT_MULTI_DRAW_EXTENSION_NAME);
+
     // VK_KHR_pipeline_executable_properties
     if (Settings::values.renderer_shader_feedback.GetValue()) {
         extensions.pipeline_executable_properties =
@@ -1236,6 +1402,76 @@ void Device::RemoveUnsuitableExtensions() {
     RemoveExtensionFeatureIfUnsuitable(extensions.workgroup_memory_explicit_layout,
                                        features.workgroup_memory_explicit_layout,
                                        VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME);
+
+    // VK_EXT_swapchain_maintenance1 (extension only, has features)
+    // Requires VK_EXT_surface_maintenance1 instance extension
+    extensions.swapchain_maintenance1 = features.swapchain_maintenance1.swapchainMaintenance1;
+    if (extensions.swapchain_maintenance1) {
+        // Check if VK_EXT_surface_maintenance1 instance extension is available
+        const auto instance_extensions = vk::EnumerateInstanceExtensionProperties(dld);
+        const bool has_surface_maintenance1 = instance_extensions && std::ranges::any_of(*instance_extensions,
+            [](const VkExtensionProperties& prop) {
+                return std::strcmp(prop.extensionName, VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME) == 0;
+            });
+        if (!has_surface_maintenance1) {
+            LOG_WARNING(Render_Vulkan,
+                        "VK_EXT_swapchain_maintenance1 requires VK_EXT_surface_maintenance1, disabling");
+            extensions.swapchain_maintenance1 = false;
+            features.swapchain_maintenance1.swapchainMaintenance1 = false;
+        }
+    }
+    RemoveExtensionFeatureIfUnsuitable(extensions.swapchain_maintenance1, features.swapchain_maintenance1,
+                                       VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME);
+
+    // VK_KHR_maintenance1 (core in Vulkan 1.1, no features)
+    extensions.maintenance1 = loaded_extensions.contains(VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
+    RemoveExtensionIfUnsuitable(extensions.maintenance1, VK_KHR_MAINTENANCE_1_EXTENSION_NAME);
+
+    // VK_KHR_maintenance2 (core in Vulkan 1.1, no features)
+    extensions.maintenance2 = loaded_extensions.contains(VK_KHR_MAINTENANCE_2_EXTENSION_NAME);
+    RemoveExtensionIfUnsuitable(extensions.maintenance2, VK_KHR_MAINTENANCE_2_EXTENSION_NAME);
+
+    // VK_KHR_maintenance3 (core in Vulkan 1.1, no features)
+    extensions.maintenance3 = loaded_extensions.contains(VK_KHR_MAINTENANCE_3_EXTENSION_NAME);
+    RemoveExtensionIfUnsuitable(extensions.maintenance3, VK_KHR_MAINTENANCE_3_EXTENSION_NAME);
+
+    // VK_KHR_maintenance4
+    extensions.maintenance4 = features.maintenance4.maintenance4;
+    RemoveExtensionFeatureIfUnsuitable(extensions.maintenance4, features.maintenance4,
+                                       VK_KHR_MAINTENANCE_4_EXTENSION_NAME);
+
+    // VK_KHR_maintenance5
+    extensions.maintenance5 = features.maintenance5.maintenance5;
+    
+    if (extensions.maintenance5) {
+        LOG_INFO(Render_Vulkan, "VK_KHR_maintenance5 properties: polygonModePointSize={} "
+                                "depthStencilSwizzleOne={} earlyFragmentTests={} nonStrictWideLines={}",
+                 properties.maintenance5.polygonModePointSize,
+                 properties.maintenance5.depthStencilSwizzleOneSupport,
+                 properties.maintenance5.earlyFragmentMultisampleCoverageAfterSampleCounting &&
+                 properties.maintenance5.earlyFragmentSampleMaskTestBeforeSampleCounting,
+                 properties.maintenance5.nonStrictWideLinesUseParallelogram);
+    }
+    
+    RemoveExtensionFeatureIfUnsuitable(extensions.maintenance5, features.maintenance5,
+                                       VK_KHR_MAINTENANCE_5_EXTENSION_NAME);
+
+    // VK_KHR_maintenance6
+    extensions.maintenance6 = features.maintenance6.maintenance6;
+    RemoveExtensionFeatureIfUnsuitable(extensions.maintenance6, features.maintenance6,
+                                       VK_KHR_MAINTENANCE_6_EXTENSION_NAME);
+
+    // VK_KHR_maintenance7 (proposed for Vulkan 1.4, no features)
+    extensions.maintenance7 = loaded_extensions.contains(VK_KHR_MAINTENANCE_7_EXTENSION_NAME);
+    RemoveExtensionIfUnsuitable(extensions.maintenance7, VK_KHR_MAINTENANCE_7_EXTENSION_NAME);
+
+    // VK_KHR_maintenance8 (proposed for Vulkan 1.4, no features)
+    extensions.maintenance8 = loaded_extensions.contains(VK_KHR_MAINTENANCE_8_EXTENSION_NAME);
+    RemoveExtensionIfUnsuitable(extensions.maintenance8, VK_KHR_MAINTENANCE_8_EXTENSION_NAME);
+
+    // VK_KHR_maintenance9 (proposed for Vulkan 1.4, no features)
+    extensions.maintenance9 = loaded_extensions.contains(VK_KHR_MAINTENANCE_9_EXTENSION_NAME);
+    RemoveExtensionIfUnsuitable(extensions.maintenance9, VK_KHR_MAINTENANCE_9_EXTENSION_NAME);
 }
 
 void Device::SetupFamilies(VkSurfaceKHR surface) {

src/video_core/vulkan_common/vulkan_device.h

@@ -37,9 +37,13 @@ VK_DEFINE_HANDLE(VmaAllocator)
     FEATURE(KHR, TimelineSemaphore, TIMELINE_SEMAPHORE, timeline_semaphore)
 
 #define FOR_EACH_VK_FEATURE_1_3(FEATURE)                                                           \
+    FEATURE(EXT, ImageRobustness, IMAGE_ROBUSTNESS, image_robustness)                              \
     FEATURE(EXT, ShaderDemoteToHelperInvocation, SHADER_DEMOTE_TO_HELPER_INVOCATION,               \
             shader_demote_to_helper_invocation)                                                    \
-    FEATURE(EXT, SubgroupSizeControl, SUBGROUP_SIZE_CONTROL, subgroup_size_control)
+    FEATURE(EXT, SubgroupSizeControl, SUBGROUP_SIZE_CONTROL, subgroup_size_control)                \
+    FEATURE(KHR, Maintenance4, MAINTENANCE_4, maintenance4)
+
+#define FOR_EACH_VK_FEATURE_1_4(FEATURE)
 
 // Define all features which may be used by the implementation and require an extension here.
 #define FOR_EACH_VK_FEATURE_EXT(FEATURE)                                                           \
@@ -52,12 +56,16 @@ VK_DEFINE_HANDLE(VmaAllocator)
     FEATURE(EXT, 4444Formats, 4444_FORMATS, format_a4b4g4r4)                                       \
     FEATURE(EXT, IndexTypeUint8, INDEX_TYPE_UINT8, index_type_uint8)                               \
     FEATURE(EXT, LineRasterization, LINE_RASTERIZATION, line_rasterization)                        \
+    FEATURE(EXT, MultiDraw, MULTI_DRAW, multi_draw)                                                \
     FEATURE(EXT, PrimitiveTopologyListRestart, PRIMITIVE_TOPOLOGY_LIST_RESTART,                    \
             primitive_topology_list_restart)                                                       \
     FEATURE(EXT, ProvokingVertex, PROVOKING_VERTEX, provoking_vertex)                              \
     FEATURE(EXT, Robustness2, ROBUSTNESS_2, robustness2)                                           \
     FEATURE(EXT, TransformFeedback, TRANSFORM_FEEDBACK, transform_feedback)                        \
     FEATURE(EXT, VertexInputDynamicState, VERTEX_INPUT_DYNAMIC_STATE, vertex_input_dynamic_state)  \
+    FEATURE(EXT, SwapchainMaintenance1, SWAPCHAIN_MAINTENANCE_1, swapchain_maintenance1)           \
+    FEATURE(KHR, Maintenance5, MAINTENANCE_5, maintenance5)                                        \
+    FEATURE(KHR, Maintenance6, MAINTENANCE_6, maintenance6)                                        \
     FEATURE(KHR, PipelineExecutableProperties, PIPELINE_EXECUTABLE_PROPERTIES,                     \
             pipeline_executable_properties)                                                        \
     FEATURE(KHR, WorkgroupMemoryExplicitLayout, WORKGROUP_MEMORY_EXPLICIT_LAYOUT,                  \
@@ -84,6 +92,12 @@ VK_DEFINE_HANDLE(VmaAllocator)
     EXTENSION(KHR, SWAPCHAIN, swapchain)                                                           \
     EXTENSION(KHR, SWAPCHAIN_MUTABLE_FORMAT, swapchain_mutable_format)                             \
     EXTENSION(KHR, IMAGE_FORMAT_LIST, image_format_list)                                           \
+    EXTENSION(KHR, MAINTENANCE_1, maintenance1)                                                    \
+    EXTENSION(KHR, MAINTENANCE_2, maintenance2)                                                    \
+    EXTENSION(KHR, MAINTENANCE_3, maintenance3)                                                    \
+    EXTENSION(KHR, MAINTENANCE_7, maintenance7)                                                    \
+    EXTENSION(KHR, MAINTENANCE_8, maintenance8)                                                    \
+    EXTENSION(KHR, MAINTENANCE_9, maintenance9)                                                    \
     EXTENSION(NV, DEVICE_DIAGNOSTICS_CONFIG, device_diagnostics_config)                            \
     EXTENSION(NV, GEOMETRY_SHADER_PASSTHROUGH, geometry_shader_passthrough)                        \
     EXTENSION(NV, VIEWPORT_ARRAY2, viewport_array2)                                                \
@@ -110,6 +124,7 @@ VK_DEFINE_HANDLE(VmaAllocator)
     EXTENSION_NAME(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME)                                 \
     EXTENSION_NAME(VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME)                                     \
     EXTENSION_NAME(VK_EXT_4444_FORMATS_EXTENSION_NAME)                                             \
+    EXTENSION_NAME(VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME)                                         \
     EXTENSION_NAME(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)                                       \
     EXTENSION_NAME(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)                                             \
     EXTENSION_NAME(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME)                               \
@@ -161,6 +176,7 @@ VK_DEFINE_HANDLE(VmaAllocator)
     FEATURE_NAME(depth_bias_control, depthBiasExact)                                               \
     FEATURE_NAME(extended_dynamic_state, extendedDynamicState)                                     \
     FEATURE_NAME(format_a4b4g4r4, formatA4B4G4R4)                                                  \
+    FEATURE_NAME(image_robustness, robustImageAccess)                                              \
     FEATURE_NAME(index_type_uint8, indexTypeUint8)                                                 \
     FEATURE_NAME(primitive_topology_list_restart, primitiveTopologyListRestart)                    \
     FEATURE_NAME(provoking_vertex, provokingVertexLast)                                            \
@@ -440,6 +456,11 @@ public:
         return extensions.swapchain_mutable_format;
     }
 
+    /// Returns true if VK_EXT_swapchain_maintenance1 is enabled.
+    bool IsExtSwapchainMaintenance1Enabled() const {
+        return extensions.swapchain_maintenance1;
+    }
+
     /// Returns true if VK_KHR_shader_float_controls is enabled.
     bool IsKhrShaderFloatControlsSupported() const {
         return extensions.shader_float_controls;
@@ -476,10 +497,18 @@ public:
     }
 
     /// Returns true if the device supports VK_EXT_shader_stencil_export.
+    /// Note: Most Mali/NVIDIA drivers don't support this. Use hardware blits as fallback.
     bool IsExtShaderStencilExportSupported() const {
         return extensions.shader_stencil_export;
     }
 
+    /// Returns true if depth/stencil operations can be performed efficiently.
+    /// Either through shader export or hardware blits.
+    bool CanPerformDepthStencilOperations() const {
+        return extensions.shader_stencil_export || is_blit_depth24_stencil8_supported ||
+               is_blit_depth32_stencil8_supported;
+    }
+
     /// Returns true if the device supports VK_EXT_depth_range_unrestricted.
     bool IsExtDepthRangeUnrestrictedSupported() const {
         return extensions.depth_range_unrestricted;
@@ -520,6 +549,46 @@ public:
         return extensions.custom_border_color;
     }
 
+    /// Returns true if the device supports VK_EXT_image_robustness.
+    bool IsExtImageRobustnessSupported() const {
+        return extensions.image_robustness;
+    }
+
+    /// Returns true if robustImageAccess is supported.
+    bool IsRobustImageAccessSupported() const {
+        return features.image_robustness.robustImageAccess;
+    }
+
+    /// Returns true if the device supports VK_EXT_robustness2.
+    bool IsExtRobustness2Supported() const {
+        return extensions.robustness_2;
+    }
+
+    /// Returns true if robustBufferAccess2 is supported.
+    bool IsRobustBufferAccess2Supported() const {
+        return features.robustness2.robustBufferAccess2;
+    }
+
+    /// Returns true if robustImageAccess2 is supported.
+    bool IsRobustImageAccess2Supported() const {
+        return features.robustness2.robustImageAccess2;
+    }
+
+    /// Returns true if nullDescriptor is supported.
+    bool IsNullDescriptorSupported() const {
+        return features.robustness2.nullDescriptor;
+    }
+
+    /// Returns true if customBorderColors feature is available.
+    bool IsCustomBorderColorsSupported() const {
+        return features.custom_border_color.customBorderColors;
+    }
+
+    /// Returns true if customBorderColorWithoutFormat feature is available.
+    bool IsCustomBorderColorWithoutFormatSupported() const {
+        return features.custom_border_color.customBorderColorWithoutFormat;
+    }
+
     /// Returns true if the device supports VK_EXT_extended_dynamic_state.
     bool IsExtExtendedDynamicStateSupported() const {
         return extensions.extended_dynamic_state;
@@ -569,6 +638,55 @@ public:
         return extensions.line_rasterization;
     }
 
+    bool SupportsRectangularLines() const {
+        return features.line_rasterization.rectangularLines != VK_FALSE;
+    }
+
+    bool SupportsSmoothLines() const {
+        return features.line_rasterization.smoothLines != VK_FALSE;
+    }
+
+    bool SupportsStippledRectangularLines() const {
+        return features.line_rasterization.stippledRectangularLines != VK_FALSE;
+    }
+
+    bool SupportsAlphaToOne() const {
+        return features.features.alphaToOne != VK_FALSE;
+    }
+
+    bool SupportsDynamicState3DepthClampEnable() const {
+        return dynamic_state3_depth_clamp_enable;
+    }
+
+    bool SupportsDynamicState3LogicOpEnable() const {
+        return dynamic_state3_logic_op_enable;
+    }
+
+    bool SupportsDynamicState3LineRasterizationMode() const {
+        return dynamic_state3_line_raster_mode;
+    }
+
+    bool SupportsDynamicState3ConservativeRasterizationMode() const {
+        return dynamic_state3_conservative_raster_mode;
+    }
+
+    bool SupportsDynamicState3LineStippleEnable() const {
+        return dynamic_state3_line_stipple_enable;
+    }
+
+    bool SupportsDynamicState3AlphaToCoverageEnable() const {
+        return dynamic_state3_alpha_to_coverage;
+    }
+
+    bool SupportsDynamicState3AlphaToOneEnable() const {
+        return dynamic_state3_alpha_to_one;
+    }
+
+    /// Returns true when the user enabled extended core dynamic states (level > 0).
+    bool UsesAdvancedCoreDynamicState() const {
+        return Settings::values.dyna_state.GetValue() > 0;
+    }
+
     /// Returns true if the device supports VK_EXT_vertex_input_dynamic_state.
     bool IsExtVertexInputDynamicStateSupported() const {
         return extensions.vertex_input_dynamic_state;
@@ -703,6 +821,73 @@ public:
         return features2.features.multiViewport;
     }
 
+    /// Returns true if the device supports VK_KHR_maintenance1.
+    bool IsKhrMaintenance1Supported() const {
+        return extensions.maintenance1;
+    }
+
+    /// Returns true if the device supports VK_KHR_maintenance2.
+    bool IsKhrMaintenance2Supported() const {
+        return extensions.maintenance2;
+    }
+
+    /// Returns true if the device supports VK_KHR_maintenance3.
+    bool IsKhrMaintenance3Supported() const {
+        return extensions.maintenance3;
+    }
+
+    /// Returns true if the device supports VK_KHR_maintenance4.
+    bool IsKhrMaintenance4Supported() const {
+        return extensions.maintenance4;
+    }
+
+    /// Returns true if the device supports VK_KHR_maintenance5.
+    bool IsKhrMaintenance5Supported() const {
+        return extensions.maintenance5;
+    }
+
+    /// Returns true if polygon mode POINT supports gl_PointSize.
+    bool SupportsPolygonModePointSize() const {
+        return extensions.maintenance5 && properties.maintenance5.polygonModePointSize;
+    }
+
+    /// Returns true if depth/stencil swizzle ONE is supported.
+    bool SupportsDepthStencilSwizzleOne() const {
+        return extensions.maintenance5 && properties.maintenance5.depthStencilSwizzleOneSupport;
+    }
+
+    /// Returns true if early fragment tests optimizations are available.
+    bool SupportsEarlyFragmentTests() const {
+        return extensions.maintenance5 && 
+               properties.maintenance5.earlyFragmentMultisampleCoverageAfterSampleCounting &&
+               properties.maintenance5.earlyFragmentSampleMaskTestBeforeSampleCounting;
+    }
+
+    /// Returns true if the device supports VK_KHR_maintenance6.
+    bool IsKhrMaintenance6Supported() const {
+        return extensions.maintenance6;
+    }
+
+    /// Returns true if the device supports VK_EXT_multi_draw.
+    bool IsExtMultiDrawSupported() const {
+        return extensions.multi_draw;
+    }
+
+    /// Returns true if the device supports VK_KHR_maintenance7.
+    bool IsKhrMaintenance7Supported() const {
+        return extensions.maintenance7;
+    }
+
+    /// Returns true if the device supports VK_KHR_maintenance8.
+    bool IsKhrMaintenance8Supported() const {
+        return extensions.maintenance8;
+    }
+
+    /// Returns true if the device supports VK_KHR_maintenance9.
+    bool IsKhrMaintenance9Supported() const {
+        return extensions.maintenance9;
+    }
+
     [[nodiscard]] static constexpr bool CheckBrokenCompute(VkDriverId driver_id,
                                                            u32 driver_version) {
         if (driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS) {
@@ -786,6 +971,7 @@ private:
         FOR_EACH_VK_FEATURE_1_1(FEATURE);
         FOR_EACH_VK_FEATURE_1_2(FEATURE);
         FOR_EACH_VK_FEATURE_1_3(FEATURE);
+        FOR_EACH_VK_FEATURE_1_4(FEATURE);
         FOR_EACH_VK_FEATURE_EXT(FEATURE);
         FOR_EACH_VK_EXTENSION(EXTENSION);
 
@@ -802,6 +988,7 @@ private:
         FOR_EACH_VK_FEATURE_1_1(FEATURE_CORE);
         FOR_EACH_VK_FEATURE_1_2(FEATURE_CORE);
         FOR_EACH_VK_FEATURE_1_3(FEATURE_CORE);
+        FOR_EACH_VK_FEATURE_1_4(FEATURE_CORE);
         FOR_EACH_VK_FEATURE_EXT(FEATURE_EXT);
 
 #undef FEATURE_CORE
@@ -817,6 +1004,8 @@ private:
         VkPhysicalDevicePushDescriptorPropertiesKHR push_descriptor{};
         VkPhysicalDeviceSubgroupSizeControlProperties subgroup_size_control{};
         VkPhysicalDeviceTransformFeedbackPropertiesEXT transform_feedback{};
+        VkPhysicalDeviceMaintenance5PropertiesKHR maintenance5{};
+        VkPhysicalDeviceMultiDrawPropertiesEXT multi_draw{};
 
         VkPhysicalDeviceProperties properties{};
     };
@@ -846,8 +1035,15 @@ private:
     bool cant_blit_msaa{};                     ///< Does not support MSAA<->MSAA blitting.
     bool must_emulate_scaled_formats{};        ///< Requires scaled vertex format emulation
     bool must_emulate_bgr565{};                ///< Emulates BGR565 by swizzling RGB565 format.
-    bool dynamic_state3_blending{};            ///< Has all blending features of dynamic_state3.
-    bool dynamic_state3_enables{};             ///< Has all enables features of dynamic_state3.
+    bool dynamic_state3_blending{};            ///< Has blending features of dynamic_state3.
+    bool dynamic_state3_enables{};             ///< Has at least one enable feature of dynamic_state3.
+    bool dynamic_state3_depth_clamp_enable{};
+    bool dynamic_state3_logic_op_enable{};
+    bool dynamic_state3_line_raster_mode{};
+    bool dynamic_state3_conservative_raster_mode{};
+    bool dynamic_state3_line_stipple_enable{};
+    bool dynamic_state3_alpha_to_coverage{};
+    bool dynamic_state3_alpha_to_one{};
     bool supports_conditional_barriers{};      ///< Allows barriers in conditional control flow.
     u64 device_access_memory{};                ///< Total size of device local memory in bytes.
     u32 sets_per_pool{};                       ///< Sets per Description Pool

src/video_core/vulkan_common/vulkan_instance.cpp

@@ -57,8 +57,6 @@ namespace {
     case Core::Frontend::WindowSystemType::Xcb:
         extensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
         break;
-#elif defined(__OPENORBIS__)
-    // No vulkan
 #else
     case Core::Frontend::WindowSystemType::X11:
         extensions.push_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);

src/video_core/vulkan_common/vulkan_surface.cpp

@@ -74,8 +74,6 @@ vk::SurfaceKHR CreateSurface(
             throw vk::Exception(VK_ERROR_INITIALIZATION_FAILED);
         }
     }
-#elif defined(__OPENORBIS__)
-    // No native
 #else
     if (window_info.type == Core::Frontend::WindowSystemType::X11) {
         const VkXlibSurfaceCreateInfoKHR xlib_ci{

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -116,6 +116,8 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkCmdDrawIndirectCount);
     X(vkCmdDrawIndexedIndirectCount);
     X(vkCmdDrawIndirectByteCountEXT);
+    X(vkCmdDrawMultiEXT);
+    X(vkCmdDrawMultiIndexedEXT);
     X(vkCmdEndConditionalRenderingEXT);
     X(vkCmdEndQuery);
     X(vkCmdEndRenderPass);
@@ -145,6 +147,8 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkCmdSetDepthWriteEnableEXT);
     X(vkCmdSetPrimitiveRestartEnableEXT);
     X(vkCmdSetRasterizerDiscardEnableEXT);
+    X(vkCmdSetAlphaToCoverageEnableEXT);
+    X(vkCmdSetAlphaToOneEnableEXT);
     X(vkCmdSetConservativeRasterizationModeEXT);
     X(vkCmdSetLineRasterizationModeEXT);
     X(vkCmdSetLineStippleEnableEXT);

src/video_core/vulkan_common/vulkan_wrapper.h

@@ -216,6 +216,8 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount{};
     PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount{};
     PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT{};
+    PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT{};
+    PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT{};
     PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT{};
     PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT{};
     PFN_vkCmdEndQuery vkCmdEndQuery{};
@@ -238,6 +240,8 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT{};
     PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT{};
     PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT{};
+    PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT{};
+    PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT{};
     PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT{};
     PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT{};
     PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT{};
@@ -1239,6 +1243,19 @@ public:
                                            counter_buffer_offset, counter_offset, stride);
     }
 
+    void DrawMultiEXT(u32 draw_count, const VkMultiDrawInfoEXT* vertex_info,
+                      u32 instance_count, u32 first_instance, u32 stride) const noexcept {
+        dld->vkCmdDrawMultiEXT(handle, draw_count, vertex_info, instance_count, first_instance,
+                               stride);
+    }
+
+    void DrawMultiIndexedEXT(u32 draw_count, const VkMultiDrawIndexedInfoEXT* index_info,
+                             u32 instance_count, u32 first_instance, u32 stride,
+                             const int32_t* vertex_offset) const noexcept {
+        dld->vkCmdDrawMultiIndexedEXT(handle, draw_count, index_info, instance_count,
+                                      first_instance, stride, vertex_offset);
+    }
+
     void ClearAttachments(Span<VkClearAttachment> attachments,
                           Span<VkClearRect> rects) const noexcept {
         dld->vkCmdClearAttachments(handle, attachments.size(), attachments.data(), rects.size(),
@@ -1471,6 +1488,14 @@ public:
         dld->vkCmdSetLogicOpEnableEXT(handle, enable ? VK_TRUE : VK_FALSE);
     }
 
+    void SetAlphaToCoverageEnableEXT(bool enable) const noexcept {
+        dld->vkCmdSetAlphaToCoverageEnableEXT(handle, enable ? VK_TRUE : VK_FALSE);
+    }
+
+    void SetAlphaToOneEnableEXT(bool enable) const noexcept {
+        dld->vkCmdSetAlphaToOneEnableEXT(handle, enable ? VK_TRUE : VK_FALSE);
+    }
+
     void SetDepthClampEnableEXT(bool enable) const noexcept {
         dld->vkCmdSetDepthClampEnableEXT(handle, enable ? VK_TRUE : VK_FALSE);
     }

src/yuzu/CMakeLists.txt

@@ -435,8 +435,7 @@ if (YUZU_USE_BUNDLED_QT)
 endif()
 
 if (ENABLE_SDL2)
-    target_include_directories(yuzu PRIVATE ${CMAKE_SYSROOT}/include/SDL2)
-    target_link_libraries(yuzu PRIVATE SDL2)
+    target_link_libraries(yuzu PRIVATE SDL2::SDL2)
     target_compile_definitions(yuzu PRIVATE HAVE_SDL2)
 endif()
 

src/yuzu_cmd/CMakeLists.txt

@@ -34,16 +34,13 @@ target_link_libraries(yuzu-cmd PRIVATE common core input_common frontend_common
 target_link_libraries(yuzu-cmd PRIVATE glad)
 if (MSVC)
     target_link_libraries(yuzu-cmd PRIVATE getopt)
-elseif(PLATFORM_PS4)
-    target_link_libraries(yuzu-cmd PRIVATE SceVideoOut SceAudioOut ScePad SceSystemService)
 endif()
 target_link_libraries(yuzu-cmd PRIVATE ${PLATFORM_LIBRARIES} Threads::Threads)
 
 create_resource("../../dist/yuzu.bmp" "yuzu_cmd/yuzu_icon.h" "yuzu_icon")
 target_include_directories(yuzu-cmd PRIVATE ${RESOURCES_DIR})
 
-target_include_directories(yuzu-cmd PRIVATE ${CMAKE_SYSROOT}/include/SDL2)
-target_link_libraries(yuzu-cmd PRIVATE SDL2)
+target_link_libraries(yuzu-cmd PRIVATE SDL2::SDL2)
 
 if(UNIX AND NOT APPLE)
     install(TARGETS yuzu-cmd)
@@ -68,7 +65,3 @@ if (NOT MSVC)
         -Wno-unused-parameter
         -Wno-missing-field-initializers)
 endif()
-
-if (PLATFORM_PS4)
-    create_ps4_pkg(yuzu-cmd eden-cli IV0000-BREW00090_00-EDENEMULAT000000)
-endif()

src/yuzu_cmd/emu_window/emu_window_sdl2_vk.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -77,12 +74,6 @@ EmuWindow_SDL2_VK::EmuWindow_SDL2_VK(InputCommon::InputSubsystem* input_subsyste
         window_info.type = Core::Frontend::WindowSystemType::Android;
         window_info.render_surface = reinterpret_cast<void*>(wm.info.android.window);
         break;
-#endif
-#ifdef SDL_VIDEO_DRIVER_DIRECTFB
-    case SDL_SYSWM_TYPE::SDL_SYSWM_DIRECTFB:
-        window_info.type = Core::Frontend::WindowSystemType::Headless;
-        window_info.render_surface = reinterpret_cast<void*>(wm.info.dfb.window);
-        break;
 #endif
     default:
         LOG_CRITICAL(Frontend, "Window manager subsystem {} not implemented", wm.subsystem);

src/yuzu_cmd/yuzu.cpp

@@ -51,20 +51,7 @@
 #include <unistd.h>
 #endif
 
-#ifdef __OPENORBIS__
-#include <orbis/SystemService.h>
-#include <cxxabi.h>
-#include <__thread/support.h>
-#   define STUB_WEAK(name) extern "C" void name() { printf("called " #name); asm volatile("ud2"); }
-void *__cxa_thread_atexit_impl = nullptr;
-STUB_WEAK(__assert)
-STUB_WEAK(ZSTD_trace_compress_begin)
-STUB_WEAK(ZSTD_trace_compress_end)
-STUB_WEAK(ZSTD_trace_decompress_begin)
-STUB_WEAK(ZSTD_trace_decompress_end)
-FILE* __stderrp = stdout;
-#   undef STUB_WEAK
-#elif defined(_WIN32)
+#ifdef _WIN32
 extern "C" {
 // tells Nvidia and AMD drivers to use the dedicated GPU by default on laptops with switchable
 // graphics
@@ -237,11 +224,7 @@ int main(int argc, char** argv) {
         {0, 0, 0, 0},
         // clang-format on
     };
-#ifdef __OPENORBIS__
-    // PS4 will use this path by default UNLESS overriden; this is so users
-    // can quickly launch whatever they want.
-    filepath = "/data/eden/games/test.nro";
-#endif
+
     while (optind < argc) {
         int arg = getopt_long(argc, argv, "g:fhvp::c:u:d:", long_options, &option_index);
         if (arg != -1) {
@@ -436,20 +419,10 @@ int main(int argc, char** argv) {
             [](VideoCore::LoadCallbackStage, size_t value, size_t total) {});
     }
 
-    auto const exit_fn = [&] {
-#ifdef __OPENORBIS__
-        sceSystemServiceLoadExec("EXIT", nullptr);
-#else
+    system.RegisterExitCallback([&] {
         // Just exit right away.
         exit(0);
-#endif
-    };
-    system.RegisterExitCallback(exit_fn);
-
-#ifdef __linux__
-    Common::Linux::StartGamemode();
-#endif
-
+    });
     void(system.Run());
     if (system.DebuggerEnabled()) {
         system.InitializeDebugger();
@@ -461,7 +434,6 @@ int main(int argc, char** argv) {
     void(system.Pause());
     system.ShutdownMainProcess();
     detached_tasks.WaitForAllTasks();
-    exit_fn();
     return 0;
 }