2026-09-07 20:08:08

Signed-off-by: lizzie <lizzie@eden-emu.dev>

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt

@@ -83,6 +83,7 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     SHOW_SHADERS_BUILDING("show_shaders_building"),
 
     DEBUG_FLUSH_BY_LINE("flush_line"),
+    EXTENDED_LOGGING("extended_logging"),
     DONT_SHOW_DRIVER_SHADER_WARNING("dont_show_driver_shader_warning"),
     ENABLE_OVERLAY("enable_overlay"),
 

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt

@@ -262,6 +262,13 @@ abstract class SettingsItem(
                     descriptionId = R.string.flush_by_line_description
                 )
             )
+            put(
+                SwitchSetting(
+                    BooleanSetting.EXTENDED_LOGGING,
+                    titleId = R.string.extended_logging,
+                    descriptionId = R.string.extended_logging_description
+                )
+            )
 
             val dockedModeSetting = object : AbstractBooleanSetting {
                 override val key = BooleanSetting.USE_DOCKED_MODE.key

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt

@@ -1323,6 +1323,7 @@ class SettingsFragmentPresenter(
                 add(HeaderSetting(R.string.log))
 
                 add(BooleanSetting.DEBUG_FLUSH_BY_LINE.key)
+                add(BooleanSetting.EXTENDED_LOGGING.key)
                 add(StringSetting.LOG_FILTER.key)
             }
 

src/android/app/src/main/res/values/strings.xml

@@ -636,6 +636,8 @@
     <string name="log">Logging</string>
     <string name="flush_by_line">Flush debug logs by line</string>
     <string name="flush_by_line_description">Flushes debugging logs on each line written, making debugging easier in cases of crashing or freezing.</string>
+    <string name="extended_logging">Enable extended logging</string>
+    <string name="extended_logging_description">Increases the maximum log file size from 100 MiB to 1 GiB.</string>
     <string name="log_filter">Log filter</string>
     <string name="log_filter_description">Controls Eden\'s log categories. Example: *:Info Service.LM:Debug</string>
 

src/dynarmic/CMakeLists.txt

@@ -11,15 +11,34 @@ set(dynarmic_VERSION ${dynarmic_VERSION_MAJOR}.${dynarmic_VERSION_MINOR}.${dynar
 
 project(dynarmic LANGUAGES C CXX ASM VERSION ${dynarmic_VERSION})
 
+# Determine if we're built as a subproject (using add_subdirectory)
+# or if this is the master project.
+set(MASTER_PROJECT OFF)
+if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+  set(MASTER_PROJECT ON)
+endif()
+
+if (MASTER_PROJECT)
+    include(CTest)
+endif()
+
+# Dynarmic project options
+option(DYNARMIC_ENABLE_CPU_FEATURE_DETECTION "Turning this off causes dynarmic to assume the host CPU doesn't support anything later than SSE3" ON)
+
 if (OPENBSD OR DRAGONFLY OR NETBSD)
     set(REQUIRE_WX ON)
 else()
     set(REQUIRE_WX OFF)
 endif()
 option(DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT "Enables support for systems that require W^X" ${REQUIRE_WX})
+
+option(DYNARMIC_IGNORE_ASSERTS "Ignore asserts" ON)
 option(DYNARMIC_TESTS_USE_UNICORN "Enable fuzzing tests against unicorn" OFF)
 CMAKE_DEPENDENT_OPTION(DYNARMIC_USE_LLVM "Support disassembly of jitted x86_64 code using LLVM" OFF "NOT YUZU_DISABLE_LLVM" OFF)
 
+option(DYNARMIC_INSTALL "Install dynarmic headers and CMake files" OFF)
+option(DYNARMIC_USE_BUNDLED_EXTERNALS "Use all bundled externals (useful when e.g. cross-compiling)" OFF)
+
 # Set hard requirements for C++
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
@@ -69,7 +88,7 @@ if (MSVC)
              -Wno-missing-braces)
     endif()
 else()
-    list(APPEND DYNARMIC_CXX_FLAGS
+    set(DYNARMIC_CXX_FLAGS
         -Wall
         -Wextra
         -Wcast-qual
@@ -84,35 +103,37 @@ else()
         # to Address& after first checking isMEM(), and that code is inlined in a situation where
         # GCC knows that the variable is actually a Reg64.  isMEM() will never return true for a
         # Reg64, but GCC doesn't know that.
-        list(APPEND DYNARMIC_CXX_FLAGS
-            -Wno-array-bounds
-            -Wstack-usage=4096)
+        list(APPEND DYNARMIC_CXX_FLAGS -Wno-array-bounds)
+        list(APPEND DYNARMIC_CXX_FLAGS -Wstack-usage=4096)
     endif()
     if (CXX_CLANG)
-        list(APPEND DYNARMIC_CXX_FLAGS
-            # Bracket depth determines maximum size of a fold expression in Clang since 9c9974c3ccb6.
-            # And this in turns limits the size of a std::array.
-            -fbracket-depth=1024
-            # Clang mistakenly blames CMake for using unused arguments during compilation
-            -Wno-unused-command-line-argument)
+        # Bracket depth determines maximum size of a fold expression in Clang since 9c9974c3ccb6.
+        # And this in turns limits the size of a std::array.
+        list(APPEND DYNARMIC_CXX_FLAGS -fbracket-depth=1024)
+        # Clang mistakenly blames CMake for using unused arguments during compilation
+        list(APPEND DYNARMIC_CXX_FLAGS -Wno-unused-command-line-argument)
     endif()
 endif()
 
 if (NOT Boost_FOUND)
     find_package(Boost 1.57 REQUIRED)
 endif()
+
 find_package(fmt 8 CONFIG)
 
-if (ARCHITECTURE_arm64)
+if ("arm64" IN_LIST ARCHITECTURE OR DYNARMIC_TESTS)
     find_package(oaknut 2.0.1 CONFIG)
 endif()
-if (ARCHITECTURE_riscv64)
+
+if ("riscv64" IN_LIST ARCHITECTURE)
     find_package(biscuit 0.9.1 REQUIRED)
 endif()
-if (ARCHITECTURE_loongarch64)
+
+if ("loongarch64" IN_LIST ARCHITECTURE)
     find_package(lagoon REQUIRED)
 endif()
-if (ARCHITECTURE_x86_64)
+
+if ("x86_64" IN_LIST ARCHITECTURE)
     find_package(xbyak 7 CONFIG)
 endif()
 
@@ -121,12 +142,44 @@ if (DYNARMIC_USE_LLVM)
     separate_arguments(LLVM_DEFINITIONS)
 endif()
 
-# Dynarmic project files
-add_subdirectory(src/dynarmic)
 if (DYNARMIC_TESTS)
     find_package(Catch2 3 CONFIG)
     if (DYNARMIC_TESTS_USE_UNICORN)
         find_package(Unicorn REQUIRED)
     endif()
+endif()
+
+# Dynarmic project files
+add_subdirectory(src/dynarmic)
+if (DYNARMIC_TESTS)
     add_subdirectory(tests)
 endif()
+
+#
+# Install
+#
+if (DYNARMIC_INSTALL)
+    include(GNUInstallDirs)
+    include(CMakePackageConfigHelpers)
+
+    install(TARGETS dynarmic EXPORT dynarmicTargets)
+    install(EXPORT dynarmicTargets
+        NAMESPACE dynarmic::
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/dynarmic"
+    )
+
+    configure_package_config_file(CMakeModules/dynarmicConfig.cmake.in
+        dynarmicConfig.cmake
+        INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/dynarmic"
+    )
+    write_basic_package_version_file(dynarmicConfigVersion.cmake
+        COMPATIBILITY SameMajorVersion
+    )
+    install(FILES
+        "${CMAKE_CURRENT_BINARY_DIR}/dynarmicConfig.cmake"
+        "${CMAKE_CURRENT_BINARY_DIR}/dynarmicConfigVersion.cmake"
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/dynarmic"
+    )
+
+    install(DIRECTORY src/dynarmic TYPE INCLUDE FILES_MATCHING PATTERN "*.h")
+endif()

src/dynarmic/CMakeModules/TargetArchitectureSpecificSources.cmake

@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+function(target_architecture_specific_sources project arch)
+    if (NOT MULTIARCH_BUILD)
+        target_sources("${project}" PRIVATE ${ARGN})
+        return()
+    endif()
+
+    foreach(input_file IN LISTS ARGN)
+        if(input_file MATCHES ".cpp$")
+            if(NOT IS_ABSOLUTE ${input_file})
+                set(input_file "${CMAKE_CURRENT_SOURCE_DIR}/${input_file}")
+            endif()
+
+            set(output_file "${CMAKE_CURRENT_BINARY_DIR}/arch_gen/${input_file}")
+            add_custom_command(
+                OUTPUT "${output_file}"
+                COMMAND ${CMAKE_COMMAND} "-Darch=${arch}"
+                                         "-Dinput_file=${input_file}"
+                                         "-Doutput_file=${output_file}"
+                                         -P "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/impl/TargetArchitectureSpecificSourcesWrapFile.cmake"
+                DEPENDS "${input_file}"
+                VERBATIM
+            )
+            target_sources(${project} PRIVATE "${output_file}")
+        endif()
+    endforeach()
+endfunction()

src/dynarmic/CMakeModules/dynarmicConfig.cmake.in

@@ -0,0 +1,31 @@
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+
+set(ARCHITECTURE "@ARCHITECTURE@")
+
+if (NOT @BUILD_SHARED_LIBS@)
+    find_dependency(Boost 1.57)
+    find_dependency(fmt 9)
+    find_dependency(mcl 0.1.12 EXACT)
+
+    if ("arm64" IN_LIST ARCHITECTURE)
+        find_dependency(oaknut 2.0.1)
+    endif()
+
+    if ("riscv" IN_LIST ARCHITECTURE)
+        find_dependency(biscuit 0.9.1)
+    endif()
+
+    if ("x86_64" IN_LIST ARCHITECTURE)
+        find_dependency(xbyak 7)
+    endif()
+
+    if (@DYNARMIC_USE_LLVM@)
+        find_dependency(LLVM)
+    endif()
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
+
+check_required_components(@PROJECT_NAME@)

src/dynarmic/CMakeModules/impl/TargetArchitectureSpecificSourcesWrapFile.cmake

@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+string(TOUPPER "${arch}" arch)
+file(READ "${input_file}" f_contents)
+file(WRITE "${output_file}" "#if defined(ARCHITECTURE_${arch})\n${f_contents}\n#endif\n")

src/dynarmic/src/dynarmic/CMakeLists.txt

@@ -1,5 +1,7 @@
 # SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 # SPDX-License-Identifier: GPL-3.0-or-later
+include(TargetArchitectureSpecificSources)
+
 add_library(dynarmic STATIC
     mcl/bit.hpp
     mcl/function_info.hpp
@@ -133,7 +135,7 @@ add_library(dynarmic STATIC
     interface/A64/config.h
 )
 
-if (ARCHITECTURE_x86_64)
+if ("x86_64" IN_LIST ARCHITECTURE)
     # Newer versions of xbyak (>= 7.25.0) have stricter checks that currently
     # fail in dynarmic
     target_compile_definitions(dynarmic PRIVATE XBYAK_STRICT_CHECK_MEM_REG_SIZE=0)
@@ -141,7 +143,7 @@ if (ARCHITECTURE_x86_64)
     target_compile_definitions(dynarmic PRIVATE XBYAK_OLD_DISP_CHECK=1)
     target_link_libraries(dynarmic PRIVATE xbyak::xbyak)
 
-    target_sources(dynarmic PRIVATE
+    target_architecture_specific_sources(dynarmic "x86_64"
         backend/x64/abi.cpp
         backend/x64/abi.h
         backend/x64/block_of_code.cpp
@@ -199,10 +201,10 @@ if (ARCHITECTURE_x86_64)
     )
 endif()
 
-if (ARCHITECTURE_arm64)
+if ("arm64" IN_LIST ARCHITECTURE)
     target_link_libraries(dynarmic PRIVATE merry::oaknut)
 
-    target_sources(dynarmic PRIVATE
+    target_architecture_specific_sources(dynarmic "arm64"
         backend/arm64/a32_jitstate.cpp
         backend/arm64/a32_jitstate.h
         backend/arm64/a64_jitstate.h
@@ -253,7 +255,7 @@ if (ARCHITECTURE_arm64)
     )
 endif()
 
-if (ARCHITECTURE_riscv64)
+if ("riscv64" IN_LIST ARCHITECTURE)
     target_link_libraries(dynarmic PRIVATE biscuit::biscuit)
 
     target_sources(dynarmic PRIVATE
@@ -293,7 +295,7 @@ if (ARCHITECTURE_riscv64)
     message(WARNING "TODO: Incomplete frontend for this host architecture")
 endif()
 
-if (ARCHITECTURE_loongarch64)
+if ("loongarch64" IN_LIST ARCHITECTURE)
     target_link_libraries(dynarmic PRIVATE lagoon::lagoon)
 
     target_sources(dynarmic PRIVATE
@@ -398,9 +400,15 @@ if (DYNARMIC_USE_LLVM)
     target_compile_definitions(dynarmic PRIVATE DYNARMIC_USE_LLVM=1 ${LLVM_DEFINITIONS})
     llvm_config(dynarmic USE_SHARED armdesc armdisassembler aarch64desc aarch64disassembler x86desc x86disassembler)
 endif()
+if (DYNARMIC_ENABLE_CPU_FEATURE_DETECTION)
+    target_compile_definitions(dynarmic PRIVATE DYNARMIC_ENABLE_CPU_FEATURE_DETECTION=1)
+endif()
 if (DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT)
     target_compile_definitions(dynarmic PRIVATE DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT=1)
 endif()
+if (DYNARMIC_IGNORE_ASSERTS)
+    target_compile_definitions(dynarmic PRIVATE MCL_IGNORE_ASSERTS=1)
+endif()
 if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
     target_compile_definitions(dynarmic PRIVATE FMT_USE_WINDOWS_H=0)
 endif()

src/dynarmic/src/dynarmic/backend/x64/block_of_code.cpp

@@ -78,6 +78,7 @@ void ProtectMemory(const void* base, size_t size, bool is_executable) {
 
 static const HostFeature features = []() {
     HostFeature f{};
+#ifdef DYNARMIC_ENABLE_CPU_FEATURE_DETECTION
     using Cpu = Xbyak::util::Cpu;
     Xbyak::util::Cpu cpu_info{};
     if (cpu_info.has(Cpu::tSSSE3)) f |= HostFeature::SSSE3;
@@ -120,6 +121,7 @@ static const HostFeature features = []() {
         }
     }
     return f;
+#endif
 }();
 HostFeature GetHostFeatures() {
     return features;

src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.h

@@ -235,7 +235,6 @@ const void* EmitReadMemoryMov(BlockOfCode& code, int value_idx, const Xbyak::Reg
             code.xadd(qword[addr], Xbyak::Reg64(value_idx));
             break;
         case 128:
-            ASSERT(Xbyak::Xmm(value_idx) != xmm0);
             code.lock();
             code.cmpxchg16b(xword[addr]);
             if (code.HasHostFeature(HostFeature::SSE41)) {

src/dynarmic/src/dynarmic/backend/x64/emit_x64_vector.cpp

@@ -6226,7 +6226,9 @@ void EmitX64::EmitVectorZeroExtend64(EmitContext& ctx, IR::Inst* inst) {
 void EmitX64::EmitVectorZeroUpper(EmitContext& ctx, IR::Inst* inst) {
     auto args = ctx.reg_alloc.GetArgumentInfo(inst);
     auto const a = ctx.reg_alloc.UseScratchXmm(code, args[0]);
+
     code.movq(a, a);  // TODO: !IsLastUse
+
     ctx.reg_alloc.DefineValue(code, inst, a);
 }
 

src/dynarmic/src/dynarmic/common/spin_lock_x64.cpp

@@ -14,6 +14,12 @@
 #include "dynarmic/backend/x64/hostloc.h"
 #include "dynarmic/common/spin_lock.h"
 
+#ifdef DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT
+static const auto default_cg_mode = Xbyak::DontSetProtectRWE;
+#else
+static const auto default_cg_mode = nullptr; //Allow RWE
+#endif
+
 namespace Dynarmic {
 
 void EmitSpinLockLock(Xbyak::CodeGenerator& code, Xbyak::Reg64 ptr, Xbyak::Reg32 tmp, bool waitpkg) {
@@ -72,13 +78,7 @@ namespace {
 struct SpinLockImpl {
     void Initialize() noexcept;
     static void GlobalInitialize() noexcept;
-    Xbyak::CodeGenerator code = Xbyak::CodeGenerator(4096
-#ifdef DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT
-        , Xbyak::DontSetProtectRWE
-#else
-        , nullptr //Allow RWE
-#endif
-    );
+    Xbyak::CodeGenerator code = Xbyak::CodeGenerator(4096, default_cg_mode);
     void (*lock)(volatile int*) = nullptr;
     void (*unlock)(volatile int*) = nullptr;
 };

src/dynarmic/src/dynarmic/frontend/decoder/decoder_detail.h

@@ -91,7 +91,7 @@ struct detail {
                 shifts[arg_index] = bit_position;
             }
         }
-#if !defined(__ANDROID__)
+#if !defined(DYNARMIC_IGNORE_ASSERTS) && !defined(__ANDROID__)
         // Avoids a MSVC ICE, and avoids Android NDK issue.
         DEBUG_ASSERT(std::all_of(masks.begin(), masks.end(), [](auto m) { return m != 0; }));
 #endif

src/dynarmic/tests/CMakeLists.txt

@@ -1,5 +1,7 @@
 # SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 # SPDX-License-Identifier: GPL-3.0-or-later
+include(TargetArchitectureSpecificSources)
+
 add_executable(dynarmic_tests
     fp/FPToFixed.cpp
     fp/FPValue.cpp
@@ -42,13 +44,13 @@ if (DYNARMIC_TESTS_USE_UNICORN)
     )
 endif()
 
-if (ARCHITECTURE_riscv64)
+if ("riscv" IN_LIST ARCHITECTURE)
     target_link_libraries(dynarmic_tests PRIVATE biscuit::biscuit)
 endif()
 
-if (ARCHITECTURE_x86_64)
+if ("x86_64" IN_LIST ARCHITECTURE)
     target_link_libraries(dynarmic_tests PRIVATE xbyak::xbyak)
-    target_sources(dynarmic_tests PRIVATE
+    target_architecture_specific_sources(dynarmic_tests "x86_64"
         x64_cpu_info.cpp
         native/preserve_xmm.cpp
     )

src/video_core/host_shaders/fxaa.frag

@@ -7,69 +7,65 @@
 #version 460
 
 #ifdef VULKAN
-
 #define BINDING_COLOR_TEXTURE 1
-
 #else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
-
 #define BINDING_COLOR_TEXTURE 0
-
 #endif
 
 layout (location = 0) in vec4 posPos;
-
 layout (location = 0) out vec4 frag_color;
-
 layout (binding = BINDING_COLOR_TEXTURE) uniform sampler2D input_texture;
 
 const float FXAA_SPAN_MAX = 8.0;
 const float FXAA_REDUCE_MUL = 1.0 / 8.0;
 const float FXAA_REDUCE_MIN = 1.0 / 128.0;
 
-#define FxaaTexLod0(t, p) textureLod(t, p, 0.0)
-#define FxaaTexOff(t, p, o) textureLodOffset(t, p, 0.0, o)
-
 vec3 FxaaPixelShader(vec4 posPos, sampler2D tex) {
-
-    vec3 rgbNW = FxaaTexLod0(tex, posPos.zw).xyz;
-    vec3 rgbNE = FxaaTexOff(tex, posPos.zw, ivec2(1,0)).xyz;
-    vec3 rgbSW = FxaaTexOff(tex, posPos.zw, ivec2(0,1)).xyz;
-    vec3 rgbSE = FxaaTexOff(tex, posPos.zw, ivec2(1,1)).xyz;
-    vec3 rgbM  = FxaaTexLod0(tex, posPos.xy).xyz;
-/*---------------------------------------------------------*/
+    mat4x3 rgb_matrix = mat4x3(
+        textureLod(tex, posPos.zw, 0.0).xyz,
+        textureLodOffset(tex, posPos.zw, 0.0, ivec2(1, 0)).xyz,
+        textureLodOffset(tex, posPos.zw, 0.0, ivec2(0, 1)).xyz,
+        textureLodOffset(tex, posPos.zw, 0.0, ivec2(1, 1)).xyz
+    );
+    vec3 rgbM  = textureLod(tex, posPos.xy, 0.0).xyz;
     vec3 luma = vec3(0.299, 0.587, 0.114);
-    float lumaNW = dot(rgbNW, luma);
-    float lumaNE = dot(rgbNE, luma);
-    float lumaSW = dot(rgbSW, luma);
-    float lumaSE = dot(rgbSE, luma);
+    // vec4(dot(m1, l), dot(m2, l), ...) => m * l
+    vec4 lume_per_rgb = luma * rgb_matrix;
     float lumaM  = dot(rgbM,  luma);
-/*---------------------------------------------------------*/
-    float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));
-    float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));
-/*---------------------------------------------------------*/
-    vec2 dir;
-    dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));
-    dir.y =  ((lumaNW + lumaSW) - (lumaNE + lumaSE));
-/*---------------------------------------------------------*/
-    float dirReduce = max(
-        (lumaNW + lumaNE + lumaSW + lumaSE) * (0.25 * FXAA_REDUCE_MUL),
-        FXAA_REDUCE_MIN);
-    float rcpDirMin = 1.0/(min(abs(dir.x), abs(dir.y)) + dirReduce);
-    dir = min(vec2( FXAA_SPAN_MAX,  FXAA_SPAN_MAX),
-          max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),
-          dir * rcpDirMin)) / textureSize(tex, 0);
-/*--------------------------------------------------------*/
+    float lumaMin = min(lumaM, min(min(lume_per_rgb.x, lume_per_rgb.y), min(lume_per_rgb.z, lume_per_rgb.w)));
+    float lumaMax = max(lumaM, max(max(lume_per_rgb.x, lume_per_rgb.y), max(lume_per_rgb.z, lume_per_rgb.w)));
+    vec2 dir = vec2(
+        -((lume_per_rgb.x + lume_per_rgb.y) - (lume_per_rgb.z + lume_per_rgb.w)),
+        +((lume_per_rgb.x + lume_per_rgb.z) - (lume_per_rgb.y + lume_per_rgb.w))
+    );
+    float rcp_dir_min = 1.0 / (min(abs(dir.x), abs(dir.y)) + max(
+        (lume_per_rgb.x + lume_per_rgb.y + lume_per_rgb.z + lume_per_rgb.w) * (0.25 * FXAA_REDUCE_MUL),
+        FXAA_REDUCE_MIN
+    ));
+    dir = min(
+        vec2(FXAA_SPAN_MAX),
+        max(vec2(-FXAA_SPAN_MAX), dir * rcp_dir_min)
+    );
+    // Constants (calculating via division is faster)
+    mat4x2 const_dir = mat4x2(
+        (1.0 / 3.0 - 0.5) / textureSize(tex, 0),
+        (2.0 / 3.0 - 0.5) / textureSize(tex, 0),
+        (0.0 / 3.0 - 0.5) / textureSize(tex, 0),
+        (3.0 / 3.0 - 0.5) / textureSize(tex, 0)
+    );
+    // dir * const_dir[i] => dir * const_dir => vec4
     vec3 rgbA = (1.0 / 2.0) * (
-        FxaaTexLod0(tex, posPos.xy + dir * (1.0 / 3.0 - 0.5)).xyz +
-        FxaaTexLod0(tex, posPos.xy + dir * (2.0 / 3.0 - 0.5)).xyz);
-    vec3 rgbB = rgbA * (1.0 / 2.0) + (1.0 / 4.0) * (
-        FxaaTexLod0(tex, posPos.xy + dir * (0.0 / 3.0 - 0.5)).xyz +
-        FxaaTexLod0(tex, posPos.xy + dir * (3.0 / 3.0 - 0.5)).xyz);
+        textureLod(tex, fma(dir, const_dir[0], posPos.xy), 0.0).xyz +
+        textureLod(tex, fma(dir, const_dir[1], posPos.xy), 0.0).xyz
+    );
+    vec3 rgbB = fma(rgbA, vec3(1.0 / 2.0), (1.0 / 4.0) * (
+        textureLod(tex, fma(dir, const_dir[2], posPos.xy), 0.0).xyz +
+        textureLod(tex, fma(dir, const_dir[3], posPos.xy), 0.0).xyz
+    ));
     float lumaB = dot(rgbB, luma);
-    if((lumaB < lumaMin) || (lumaB > lumaMax)) return rgbA;
-    return rgbB;
+    return ((lumaB < lumaMin) || (lumaB > lumaMax)) ? rgbA : rgbB;
 }
 
 void main() {
-  frag_color = vec4(FxaaPixelShader(posPos, input_texture), texture(input_texture, posPos.xy).a);
+    frag_color = vec4(FxaaPixelShader(posPos, input_texture), texture(input_texture, posPos.xy).a);
 }

src/video_core/host_shaders/fxaa.vert

@@ -7,31 +7,35 @@ out gl_PerVertex {
     vec4 gl_Position;
 };
 
-const vec2 vertices[3] =
-    vec2[3](vec2(-1,-1), vec2(3,-1), vec2(-1, 3));
-
 layout (location = 0) out vec4 posPos;
 
 #ifdef VULKAN
-
 #define BINDING_COLOR_TEXTURE 0
 #define VERTEX_ID gl_VertexIndex
-
 #else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
-
 #define BINDING_COLOR_TEXTURE 0
 #define VERTEX_ID gl_VertexID
-
 #endif
 
 layout (binding = BINDING_COLOR_TEXTURE) uniform sampler2D input_texture;
 
 const float FXAA_SUBPIX_SHIFT = 0;
-
 void main() {
-  vec2 vertex = vertices[VERTEX_ID];
-  gl_Position = vec4(vertex, 0.0, 1.0);
-  vec2 vert_tex_coord = (vertex + 1.0) / 2.0;
-  posPos.xy = vert_tex_coord;
-  posPos.zw = vert_tex_coord - (0.5 + FXAA_SUBPIX_SHIFT) / textureSize(input_texture, 0);
+    // 0b00 -> (-1, -1) 0b01 -> (-1, 3) 0b10 -> (3, -1)
+    // ((x * 4) - 1) => 3
+    // :: (v + 1) / 2 => ((x * 4) + 1) / 2
+    // => (x * 4 + 1) / 2 => x * (4 / 2) + 1 / 2
+    // :: (v+1)/2 => v/2 + 1/2 => v*(1/2) + (1/2)
+    gl_Position = vec4(vec2(
+        float(((VERTEX_ID & 1) << 2) - 1),
+        float(((VERTEX_ID & 2) << 1) - 1)
+    ), 0.0, 1.0);
+    posPos = vec2(
+        float((VERTEX_ID & 1) << 1),
+        float((VERTEX_ID & 2) << 0)
+    ).xyxy - vec4(
+        0.0,
+        0.0,
+        (0.5 + FXAA_SUBPIX_SHIFT) / textureSize(input_texture, 0)
+    );
 }