early-access version 4106

README.md

@@ -1,7 +1,7 @@
 yuzu emulator early access
 =============
 
-This is the source code for early-access 4105.
+This is the source code for early-access 4106.
 
 ## Legal Notice
 

src/core/CMakeLists.txt

@@ -775,6 +775,9 @@ add_library(core STATIC
     hle/service/nvnflinger/graphic_buffer_producer.h
     hle/service/nvnflinger/hos_binder_driver_server.cpp
     hle/service/nvnflinger/hos_binder_driver_server.h
+    hle/service/nvnflinger/hardware_composer.cpp
+    hle/service/nvnflinger/hardware_composer.h
+    hle/service/nvnflinger/hwc_layer.h
     hle/service/nvnflinger/nvnflinger.cpp
     hle/service/nvnflinger/nvnflinger.h
     hle/service/nvnflinger/parcel.h

src/core/hle/service/glue/glue.cpp

@@ -31,8 +31,11 @@ void LoopProcess(Core::System& system) {
     // Error Context
     server_manager->RegisterNamedService("ectx:aw", std::make_shared<ECTX_AW>(system));
 
-    // Notification Services for application
-    server_manager->RegisterNamedService("notif:a", std::make_shared<NOTIF_A>(system));
+    // Notification Services
+    server_manager->RegisterNamedService(
+        "notif:a", std::make_shared<INotificationServicesForApplication>(system));
+    server_manager->RegisterNamedService("notif:s",
+                                         std::make_shared<INotificationServices>(system));
 
     // Time
     auto time = std::make_shared<Time::TimeManager>(system);

src/core/hle/service/glue/notif.cpp

@@ -6,48 +6,31 @@
 
 #include "common/assert.h"
 #include "common/logging/log.h"
+#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/glue/notif.h"
 #include "core/hle/service/ipc_helpers.h"
+#include "core/hle/service/kernel_helpers.h"
 
 namespace Service::Glue {
 
-NOTIF_A::NOTIF_A(Core::System& system_) : ServiceFramework{system_, "notif:a"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {500, &NOTIF_A::RegisterAlarmSetting, "RegisterAlarmSetting"},
-        {510, &NOTIF_A::UpdateAlarmSetting, "UpdateAlarmSetting"},
-        {520, &NOTIF_A::ListAlarmSettings, "ListAlarmSettings"},
-        {530, &NOTIF_A::LoadApplicationParameter, "LoadApplicationParameter"},
-        {540, &NOTIF_A::DeleteAlarmSetting, "DeleteAlarmSetting"},
-        {1000, &NOTIF_A::Initialize, "Initialize"},
-    };
-    // clang-format on
+namespace {
+
+constexpr inline std::size_t MaxAlarms = 8;
 
-    RegisterHandlers(functions);
 }
 
-NOTIF_A::~NOTIF_A() = default;
-
-void NOTIF_A::RegisterAlarmSetting(HLERequestContext& ctx) {
-    const auto alarm_setting_buffer_size = ctx.GetReadBufferSize(0);
-    const auto application_parameter_size = ctx.GetReadBufferSize(1);
-
-    ASSERT_MSG(alarm_setting_buffer_size == sizeof(AlarmSetting),
-               "alarm_setting_buffer_size is not 0x40 bytes");
-    ASSERT_MSG(application_parameter_size <= sizeof(ApplicationParameter),
-               "application_parameter_size is bigger than 0x400 bytes");
-
-    AlarmSetting new_alarm{};
-    memcpy(&new_alarm, ctx.ReadBuffer(0).data(), sizeof(AlarmSetting));
-
-    // TODO: Count alarms per game id
-    if (alarms.size() >= max_alarms) {
+Result NotificationServiceImpl::RegisterAlarmSetting(AlarmSettingId* out_alarm_setting_id,
+                                                     const AlarmSetting& alarm_setting,
+                                                     std::span<const u8> application_parameter) {
+    if (alarms.size() > MaxAlarms) {
         LOG_ERROR(Service_NOTIF, "Alarm limit reached");
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultUnknown);
-        return;
+        R_THROW(ResultUnknown);
     }
 
+    ASSERT_MSG(application_parameter.size() <= sizeof(ApplicationParameter),
+               "application_parameter_size is bigger than 0x400 bytes");
+
+    AlarmSetting new_alarm = alarm_setting;
     new_alarm.alarm_setting_id = last_alarm_setting_id++;
     alarms.push_back(new_alarm);
 
@@ -55,100 +38,82 @@ void NOTIF_A::RegisterAlarmSetting(HLERequestContext& ctx) {
 
     LOG_WARNING(Service_NOTIF,
                 "(STUBBED) called, application_parameter_size={}, setting_id={}, kind={}, muted={}",
-                application_parameter_size, new_alarm.alarm_setting_id, new_alarm.kind,
+                application_parameter.size(), new_alarm.alarm_setting_id, new_alarm.kind,
                 new_alarm.muted);
 
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-    rb.Push(new_alarm.alarm_setting_id);
+    *out_alarm_setting_id = new_alarm.alarm_setting_id;
+    R_SUCCEED();
 }
 
-void NOTIF_A::UpdateAlarmSetting(HLERequestContext& ctx) {
-    const auto alarm_setting_buffer_size = ctx.GetReadBufferSize(0);
-    const auto application_parameter_size = ctx.GetReadBufferSize(1);
-
-    ASSERT_MSG(alarm_setting_buffer_size == sizeof(AlarmSetting),
-               "alarm_setting_buffer_size is not 0x40 bytes");
-    ASSERT_MSG(application_parameter_size <= sizeof(ApplicationParameter),
+Result NotificationServiceImpl::UpdateAlarmSetting(const AlarmSetting& alarm_setting,
+                                                   std::span<const u8> application_parameter) {
+    ASSERT_MSG(application_parameter.size() <= sizeof(ApplicationParameter),
                "application_parameter_size is bigger than 0x400 bytes");
 
-    AlarmSetting alarm_setting{};
-    memcpy(&alarm_setting, ctx.ReadBuffer(0).data(), sizeof(AlarmSetting));
-
     const auto alarm_it = GetAlarmFromId(alarm_setting.alarm_setting_id);
     if (alarm_it != alarms.end()) {
         LOG_DEBUG(Service_NOTIF, "Alarm updated");
         *alarm_it = alarm_setting;
-        // TODO: Save application parameter data
     }
 
     LOG_WARNING(Service_NOTIF,
                 "(STUBBED) called, application_parameter_size={}, setting_id={}, kind={}, muted={}",
-                application_parameter_size, alarm_setting.alarm_setting_id, alarm_setting.kind,
+                application_parameter.size(), alarm_setting.alarm_setting_id, alarm_setting.kind,
                 alarm_setting.muted);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
+    R_SUCCEED();
 }
 
-void NOTIF_A::ListAlarmSettings(HLERequestContext& ctx) {
+Result NotificationServiceImpl::ListAlarmSettings(s32* out_count,
+                                                  std::span<AlarmSetting> out_alarms) {
     LOG_INFO(Service_NOTIF, "called, alarm_count={}", alarms.size());
 
-    // TODO: Only return alarms of this game id
-    ctx.WriteBuffer(alarms);
+    const auto count = std::min(out_alarms.size(), alarms.size());
+    for (size_t i = 0; i < count; i++) {
+        out_alarms[i] = alarms[i];
+    }
 
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push(static_cast<u32>(alarms.size()));
+    *out_count = static_cast<s32>(count);
+    R_SUCCEED();
 }
 
-void NOTIF_A::LoadApplicationParameter(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto alarm_setting_id{rp.Pop<AlarmSettingId>()};
-
+Result NotificationServiceImpl::LoadApplicationParameter(u32* out_size,
+                                                         std::span<u8> out_application_parameter,
+                                                         AlarmSettingId alarm_setting_id) {
     const auto alarm_it = GetAlarmFromId(alarm_setting_id);
     if (alarm_it == alarms.end()) {
         LOG_ERROR(Service_NOTIF, "Invalid alarm setting id={}", alarm_setting_id);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultUnknown);
-        return;
+        R_THROW(ResultUnknown);
     }
 
     // TODO: Read application parameter related to this setting id
     ApplicationParameter application_parameter{};
 
     LOG_WARNING(Service_NOTIF, "(STUBBED) called, alarm_setting_id={}", alarm_setting_id);
+    std::memcpy(out_application_parameter.data(), application_parameter.data(),
+                std::min(sizeof(application_parameter), out_application_parameter.size()));
 
-    ctx.WriteBuffer(application_parameter);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-    rb.Push(static_cast<u32>(application_parameter.size()));
+    *out_size = static_cast<u32>(application_parameter.size());
+    R_SUCCEED();
 }
 
-void NOTIF_A::DeleteAlarmSetting(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto alarm_setting_id{rp.Pop<AlarmSettingId>()};
-
+Result NotificationServiceImpl::DeleteAlarmSetting(AlarmSettingId alarm_setting_id) {
     std::erase_if(alarms, [alarm_setting_id](const AlarmSetting& alarm) {
         return alarm.alarm_setting_id == alarm_setting_id;
     });
 
     LOG_INFO(Service_NOTIF, "called, alarm_setting_id={}", alarm_setting_id);
 
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
+    R_SUCCEED();
 }
 
-void NOTIF_A::Initialize(HLERequestContext& ctx) {
+Result NotificationServiceImpl::Initialize(u64 aruid) {
     // TODO: Load previous alarms from config
 
     LOG_WARNING(Service_NOTIF, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
+    R_SUCCEED();
 }
 
-std::vector<NOTIF_A::AlarmSetting>::iterator NOTIF_A::GetAlarmFromId(
+std::vector<AlarmSetting>::iterator NotificationServiceImpl::GetAlarmFromId(
     AlarmSettingId alarm_setting_id) {
     return std::find_if(alarms.begin(), alarms.end(),
                         [alarm_setting_id](const AlarmSetting& alarm) {
@@ -156,4 +121,174 @@ std::vector<NOTIF_A::AlarmSetting>::iterator NOTIF_A::GetAlarmFromId(
                         });
 }
 
+INotificationServicesForApplication::INotificationServicesForApplication(Core::System& system_)
+    : ServiceFramework{system_, "notif:a"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {500, D<&INotificationServicesForApplication::RegisterAlarmSetting>, "RegisterAlarmSetting"},
+        {510, D<&INotificationServicesForApplication::UpdateAlarmSetting>, "UpdateAlarmSetting"},
+        {520, D<&INotificationServicesForApplication::ListAlarmSettings>, "ListAlarmSettings"},
+        {530, D<&INotificationServicesForApplication::LoadApplicationParameter>, "LoadApplicationParameter"},
+        {540, D<&INotificationServicesForApplication::DeleteAlarmSetting>, "DeleteAlarmSetting"},
+        {1000, D<&INotificationServicesForApplication::Initialize>, "Initialize"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+INotificationServicesForApplication::~INotificationServicesForApplication() = default;
+
+Result INotificationServicesForApplication::RegisterAlarmSetting(
+    Out<AlarmSettingId> out_alarm_setting_id,
+    InLargeData<AlarmSetting, BufferAttr_HipcMapAlias> alarm_setting,
+    InBuffer<BufferAttr_HipcMapAlias> application_parameter) {
+    R_RETURN(impl.RegisterAlarmSetting(out_alarm_setting_id.Get(), *alarm_setting,
+                                       application_parameter));
+}
+
+Result INotificationServicesForApplication::UpdateAlarmSetting(
+    InLargeData<AlarmSetting, BufferAttr_HipcMapAlias> alarm_setting,
+    InBuffer<BufferAttr_HipcMapAlias> application_parameter) {
+    R_RETURN(impl.UpdateAlarmSetting(*alarm_setting, application_parameter));
+}
+
+Result INotificationServicesForApplication::ListAlarmSettings(
+    Out<s32> out_count, OutArray<AlarmSetting, BufferAttr_HipcMapAlias> out_alarms) {
+    R_RETURN(impl.ListAlarmSettings(out_count.Get(), out_alarms));
+}
+
+Result INotificationServicesForApplication::LoadApplicationParameter(
+    Out<u32> out_size, OutBuffer<BufferAttr_HipcMapAlias> out_application_parameter,
+    AlarmSettingId alarm_setting_id) {
+    R_RETURN(
+        impl.LoadApplicationParameter(out_size.Get(), out_application_parameter, alarm_setting_id));
+}
+
+Result INotificationServicesForApplication::DeleteAlarmSetting(AlarmSettingId alarm_setting_id) {
+    R_RETURN(impl.DeleteAlarmSetting(alarm_setting_id));
+}
+
+Result INotificationServicesForApplication::Initialize(ClientAppletResourceUserId aruid) {
+    R_RETURN(impl.Initialize(*aruid));
+}
+
+class INotificationSystemEventAccessor final
+    : public ServiceFramework<INotificationSystemEventAccessor> {
+public:
+    explicit INotificationSystemEventAccessor(Core::System& system_)
+        : ServiceFramework{system_, "INotificationSystemEventAccessor"},
+          service_context{system_, "INotificationSystemEventAccessor"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, D<&INotificationSystemEventAccessor::GetSystemEvent>, "GetSystemEvent"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+
+        notification_event =
+            service_context.CreateEvent("INotificationSystemEventAccessor:NotificationEvent");
+    }
+
+    ~INotificationSystemEventAccessor() {
+        service_context.CloseEvent(notification_event);
+    }
+
+private:
+    Result GetSystemEvent(OutCopyHandle<Kernel::KReadableEvent> out_readable_event) {
+        LOG_WARNING(Service_NOTIF, "(STUBBED) called");
+
+        *out_readable_event = &notification_event->GetReadableEvent();
+        R_SUCCEED();
+    }
+
+    KernelHelpers::ServiceContext service_context;
+    Kernel::KEvent* notification_event;
+};
+
+INotificationServices::INotificationServices(Core::System& system_)
+    : ServiceFramework{system_, "notif:s"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {500, D<&INotificationServices::RegisterAlarmSetting>, "RegisterAlarmSetting"},
+        {510, D<&INotificationServices::UpdateAlarmSetting>, "UpdateAlarmSetting"},
+        {520, D<&INotificationServices::ListAlarmSettings>, "ListAlarmSettings"},
+        {530, D<&INotificationServices::LoadApplicationParameter>, "LoadApplicationParameter"},
+        {540, D<&INotificationServices::DeleteAlarmSetting>, "DeleteAlarmSetting"},
+        {1000, D<&INotificationServices::Initialize>, "Initialize"},
+        {1010, nullptr, "ListNotifications"},
+        {1020, nullptr, "DeleteNotification"},
+        {1030, nullptr, "ClearNotifications"},
+        {1040, D<&INotificationServices::OpenNotificationSystemEventAccessor>, "OpenNotificationSystemEventAccessor"},
+        {1500, nullptr, "SetNotificationPresentationSetting"},
+        {1510, D<&INotificationServices::GetNotificationPresentationSetting>, "GetNotificationPresentationSetting"},
+        {2000, nullptr, "GetAlarmSetting"},
+        {2001, nullptr, "GetAlarmSettingWithApplicationParameter"},
+        {2010, nullptr, "MuteAlarmSetting"},
+        {2020, nullptr, "IsAlarmSettingReady"},
+        {8000, nullptr, "RegisterAppletResourceUserId"},
+        {8010, nullptr, "UnregisterAppletResourceUserId"},
+        {8999, nullptr, "GetCurrentTime"},
+        {9000, nullptr, "GetAlarmSettingNextNotificationTime"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+INotificationServices::~INotificationServices() = default;
+
+Result INotificationServices::RegisterAlarmSetting(
+    Out<AlarmSettingId> out_alarm_setting_id,
+    InLargeData<AlarmSetting, BufferAttr_HipcMapAlias> alarm_setting,
+    InBuffer<BufferAttr_HipcMapAlias> application_parameter) {
+    R_RETURN(impl.RegisterAlarmSetting(out_alarm_setting_id.Get(), *alarm_setting,
+                                       application_parameter));
+}
+
+Result INotificationServices::UpdateAlarmSetting(
+    InLargeData<AlarmSetting, BufferAttr_HipcMapAlias> alarm_setting,
+    InBuffer<BufferAttr_HipcMapAlias> application_parameter) {
+    R_RETURN(impl.UpdateAlarmSetting(*alarm_setting, application_parameter));
+}
+
+Result INotificationServices::ListAlarmSettings(
+    Out<s32> out_count, OutArray<AlarmSetting, BufferAttr_HipcMapAlias> out_alarms) {
+    R_RETURN(impl.ListAlarmSettings(out_count.Get(), out_alarms));
+}
+
+Result INotificationServices::LoadApplicationParameter(
+    Out<u32> out_size, OutBuffer<BufferAttr_HipcMapAlias> out_application_parameter,
+    AlarmSettingId alarm_setting_id) {
+    R_RETURN(
+        impl.LoadApplicationParameter(out_size.Get(), out_application_parameter, alarm_setting_id));
+}
+
+Result INotificationServices::DeleteAlarmSetting(AlarmSettingId alarm_setting_id) {
+    R_RETURN(impl.DeleteAlarmSetting(alarm_setting_id));
+}
+
+Result INotificationServices::Initialize(ClientAppletResourceUserId aruid) {
+    R_RETURN(impl.Initialize(*aruid));
+}
+
+Result INotificationServices::OpenNotificationSystemEventAccessor(
+    Out<SharedPointer<INotificationSystemEventAccessor>> out_notification_system_event_accessor) {
+    LOG_WARNING(Service_NOTIF, "(STUBBED) called");
+
+    *out_notification_system_event_accessor =
+        std::make_shared<INotificationSystemEventAccessor>(system);
+    R_SUCCEED();
+}
+
+Result INotificationServices::GetNotificationPresentationSetting(
+    Out<NotificationPresentationSetting> out_notification_presentation_setting,
+    NotificationChannel notification_channel) {
+    LOG_WARNING(Service_NOTIF, "(STUBBED) called");
+
+    *out_notification_presentation_setting = {};
+    R_SUCCEED();
+}
+
 } // namespace Service::Glue

src/core/hle/service/glue/notif.h

@@ -7,6 +7,7 @@
 #include <vector>
 
 #include "common/uuid.h"
+#include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 
 namespace Core {
@@ -15,58 +16,117 @@ class System;
 
 namespace Service::Glue {
 
-class NOTIF_A final : public ServiceFramework<NOTIF_A> {
+// This is nn::notification::AlarmSettingId
+using AlarmSettingId = u16;
+static_assert(sizeof(AlarmSettingId) == 0x2, "AlarmSettingId is an invalid size");
+
+using ApplicationParameter = std::array<u8, 0x400>;
+static_assert(sizeof(ApplicationParameter) == 0x400, "ApplicationParameter is an invalid size");
+
+struct DailyAlarmSetting {
+    s8 hour;
+    s8 minute;
+};
+static_assert(sizeof(DailyAlarmSetting) == 0x2, "DailyAlarmSetting is an invalid size");
+
+struct WeeklyScheduleAlarmSetting {
+    INSERT_PADDING_BYTES_NOINIT(0xA);
+    std::array<DailyAlarmSetting, 0x7> day_of_week;
+};
+static_assert(sizeof(WeeklyScheduleAlarmSetting) == 0x18,
+              "WeeklyScheduleAlarmSetting is an invalid size");
+
+// This is nn::notification::AlarmSetting
+struct AlarmSetting {
+    AlarmSettingId alarm_setting_id;
+    u8 kind;
+    u8 muted;
+    INSERT_PADDING_BYTES_NOINIT(0x4);
+    Common::UUID account_id;
+    u64 application_id;
+    INSERT_PADDING_BYTES_NOINIT(0x8);
+    WeeklyScheduleAlarmSetting schedule;
+};
+static_assert(sizeof(AlarmSetting) == 0x40, "AlarmSetting is an invalid size");
+
+enum class NotificationChannel : u8 {
+    Unknown0 = 0,
+};
+
+struct NotificationPresentationSetting {
+    INSERT_PADDING_BYTES_NOINIT(0x10);
+};
+static_assert(sizeof(NotificationPresentationSetting) == 0x10,
+              "NotificationPresentationSetting is an invalid size");
+
+class NotificationServiceImpl {
 public:
-    explicit NOTIF_A(Core::System& system_);
-    ~NOTIF_A() override;
+    Result RegisterAlarmSetting(AlarmSettingId* out_alarm_setting_id,
+                                const AlarmSetting& alarm_setting,
+                                std::span<const u8> application_parameter);
+    Result UpdateAlarmSetting(const AlarmSetting& alarm_setting,
+                              std::span<const u8> application_parameter);
+    Result ListAlarmSettings(s32* out_count, std::span<AlarmSetting> out_alarms);
+    Result LoadApplicationParameter(u32* out_size, std::span<u8> out_application_parameter,
+                                    AlarmSettingId alarm_setting_id);
+    Result DeleteAlarmSetting(AlarmSettingId alarm_setting_id);
+    Result Initialize(u64 aruid);
 
 private:
-    static constexpr std::size_t max_alarms = 8;
-
-    // This is nn::notification::AlarmSettingId
-    using AlarmSettingId = u16;
-    static_assert(sizeof(AlarmSettingId) == 0x2, "AlarmSettingId is an invalid size");
-
-    using ApplicationParameter = std::array<u8, 0x400>;
-    static_assert(sizeof(ApplicationParameter) == 0x400, "ApplicationParameter is an invalid size");
-
-    struct DailyAlarmSetting {
-        s8 hour;
-        s8 minute;
-    };
-    static_assert(sizeof(DailyAlarmSetting) == 0x2, "DailyAlarmSetting is an invalid size");
-
-    struct WeeklyScheduleAlarmSetting {
-        INSERT_PADDING_BYTES(0xA);
-        std::array<DailyAlarmSetting, 0x7> day_of_week;
-    };
-    static_assert(sizeof(WeeklyScheduleAlarmSetting) == 0x18,
-                  "WeeklyScheduleAlarmSetting is an invalid size");
-
-    // This is nn::notification::AlarmSetting
-    struct AlarmSetting {
-        AlarmSettingId alarm_setting_id;
-        u8 kind;
-        u8 muted;
-        INSERT_PADDING_BYTES(0x4);
-        Common::UUID account_id;
-        u64 application_id;
-        INSERT_PADDING_BYTES(0x8);
-        WeeklyScheduleAlarmSetting schedule;
-    };
-    static_assert(sizeof(AlarmSetting) == 0x40, "AlarmSetting is an invalid size");
-
-    void RegisterAlarmSetting(HLERequestContext& ctx);
-    void UpdateAlarmSetting(HLERequestContext& ctx);
-    void ListAlarmSettings(HLERequestContext& ctx);
-    void LoadApplicationParameter(HLERequestContext& ctx);
-    void DeleteAlarmSetting(HLERequestContext& ctx);
-    void Initialize(HLERequestContext& ctx);
-
     std::vector<AlarmSetting>::iterator GetAlarmFromId(AlarmSettingId alarm_setting_id);
-
     std::vector<AlarmSetting> alarms{};
     AlarmSettingId last_alarm_setting_id{};
 };
 
+class INotificationServicesForApplication final
+    : public ServiceFramework<INotificationServicesForApplication> {
+public:
+    explicit INotificationServicesForApplication(Core::System& system_);
+    ~INotificationServicesForApplication() override;
+
+private:
+    Result RegisterAlarmSetting(Out<AlarmSettingId> out_alarm_setting_id,
+                                InLargeData<AlarmSetting, BufferAttr_HipcMapAlias> alarm_setting,
+                                InBuffer<BufferAttr_HipcMapAlias> application_parameter);
+    Result UpdateAlarmSetting(InLargeData<AlarmSetting, BufferAttr_HipcMapAlias> alarm_setting,
+                              InBuffer<BufferAttr_HipcMapAlias> application_parameter);
+    Result ListAlarmSettings(Out<s32> out_count,
+                             OutArray<AlarmSetting, BufferAttr_HipcMapAlias> out_alarms);
+    Result LoadApplicationParameter(Out<u32> out_size,
+                                    OutBuffer<BufferAttr_HipcMapAlias> out_application_parameter,
+                                    AlarmSettingId alarm_setting_id);
+    Result DeleteAlarmSetting(AlarmSettingId alarm_setting_id);
+    Result Initialize(ClientAppletResourceUserId aruid);
+
+    NotificationServiceImpl impl;
+};
+
+class INotificationSystemEventAccessor;
+
+class INotificationServices final : public ServiceFramework<INotificationServices> {
+public:
+    explicit INotificationServices(Core::System& system_);
+    ~INotificationServices() override;
+
+private:
+    Result RegisterAlarmSetting(Out<AlarmSettingId> out_alarm_setting_id,
+                                InLargeData<AlarmSetting, BufferAttr_HipcMapAlias> alarm_setting,
+                                InBuffer<BufferAttr_HipcMapAlias> application_parameter);
+    Result UpdateAlarmSetting(InLargeData<AlarmSetting, BufferAttr_HipcMapAlias> alarm_setting,
+                              InBuffer<BufferAttr_HipcMapAlias> application_parameter);
+    Result ListAlarmSettings(Out<s32> out_count,
+                             OutArray<AlarmSetting, BufferAttr_HipcMapAlias> out_alarms);
+    Result LoadApplicationParameter(Out<u32> out_size,
+                                    OutBuffer<BufferAttr_HipcMapAlias> out_application_parameter,
+                                    AlarmSettingId alarm_setting_id);
+    Result DeleteAlarmSetting(AlarmSettingId alarm_setting_id);
+    Result Initialize(ClientAppletResourceUserId aruid);
+    Result OpenNotificationSystemEventAccessor(Out<SharedPointer<INotificationSystemEventAccessor>>
+                                                   out_notification_system_event_accessor);
+    Result GetNotificationPresentationSetting(
+        Out<NotificationPresentationSetting> out_notification_presentation_setting,
+        NotificationChannel notification_channel);
+
+    NotificationServiceImpl impl;
+};
 } // namespace Service::Glue

src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp

@@ -1,6 +1,8 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <boost/container/small_vector.hpp>
+
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core.h"
@@ -38,19 +40,30 @@ NvResult nvdisp_disp0::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> in
 void nvdisp_disp0::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {}
 void nvdisp_disp0::OnClose(DeviceFD fd) {}
 
-void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, android::PixelFormat format, u32 width,
-                        u32 height, u32 stride, android::BufferTransformFlags transform,
-                        const Common::Rectangle<int>& crop_rect,
-                        std::array<Service::Nvidia::NvFence, 4>& fences, u32 num_fences) {
-    const DAddr addr = nvmap.GetHandleAddress(buffer_handle);
-    LOG_TRACE(Service,
-              "Drawing from address {:X} offset {:08X} Width {} Height {} Stride {} Format {}",
-              addr, offset, width, height, stride, format);
+void nvdisp_disp0::Composite(std::span<const Nvnflinger::HwcLayer> sorted_layers) {
+    std::vector<Tegra::FramebufferConfig> output_layers;
+    std::vector<Service::Nvidia::NvFence> output_fences;
+    output_layers.reserve(sorted_layers.size());
+    output_fences.reserve(sorted_layers.size());
 
-    const Tegra::FramebufferConfig framebuffer{addr,   offset, width,     height,
-                                               stride, format, transform, crop_rect};
+    for (auto& layer : sorted_layers) {
+        output_layers.emplace_back(Tegra::FramebufferConfig{
+            .address = nvmap.GetHandleAddress(layer.buffer_handle),
+            .offset = layer.offset,
+            .width = layer.width,
+            .height = layer.height,
+            .stride = layer.stride,
+            .pixel_format = layer.format,
+            .transform_flags = layer.transform,
+            .crop_rect = layer.crop_rect,
+        });
 
-    system.GPU().RequestSwapBuffers(&framebuffer, fences, num_fences);
+        for (size_t i = 0; i < layer.acquire_fence.num_fences; i++) {
+            output_fences.push_back(layer.acquire_fence.fences[i]);
+        }
+    }
+
+    system.GPU().RequestComposite(std::move(output_layers), std::move(output_fences));
     system.SpeedLimiter().DoSpeedLimiting(system.CoreTiming().GetGlobalTimeUs());
     system.GetPerfStats().EndSystemFrame();
     system.GetPerfStats().BeginSystemFrame();

src/core/hle/service/nvdrv/devices/nvdisp_disp0.h

@@ -8,8 +8,7 @@
 #include "common/common_types.h"
 #include "common/math_util.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"
-#include "core/hle/service/nvnflinger/buffer_transform_flags.h"
-#include "core/hle/service/nvnflinger/pixel_format.h"
+#include "core/hle/service/nvnflinger/hwc_layer.h"
 
 namespace Service::Nvidia::NvCore {
 class Container;
@@ -35,11 +34,8 @@ public:
     void OnOpen(NvCore::SessionId session_id, DeviceFD fd) override;
     void OnClose(DeviceFD fd) override;
 
-    /// Performs a screen flip, drawing the buffer pointed to by the handle.
-    void flip(u32 buffer_handle, u32 offset, android::PixelFormat format, u32 width, u32 height,
-              u32 stride, android::BufferTransformFlags transform,
-              const Common::Rectangle<int>& crop_rect,
-              std::array<Service::Nvidia::NvFence, 4>& fences, u32 num_fences);
+    /// Performs a screen flip, compositing each buffer.
+    void Composite(std::span<const Nvnflinger::HwcLayer> sorted_layers);
 
     Kernel::KEvent* QueryEvent(u32 event_id) override;
 

src/core/hle/service/nvnflinger/hardware_composer.cpp

@@ -0,0 +1,215 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <boost/container/small_vector.hpp>
+
+#include "common/microprofile.h"
+#include "core/hle/service/nvdrv/devices/nvdisp_disp0.h"
+#include "core/hle/service/nvnflinger/buffer_item.h"
+#include "core/hle/service/nvnflinger/buffer_item_consumer.h"
+#include "core/hle/service/nvnflinger/buffer_queue_producer.h"
+#include "core/hle/service/nvnflinger/hardware_composer.h"
+#include "core/hle/service/nvnflinger/hwc_layer.h"
+#include "core/hle/service/nvnflinger/ui/graphic_buffer.h"
+#include "core/hle/service/vi/display/vi_display.h"
+#include "core/hle/service/vi/layer/vi_layer.h"
+
+namespace Service::Nvnflinger {
+
+namespace {
+
+s32 NormalizeSwapInterval(f32* out_speed_scale, s32 swap_interval) {
+    if (swap_interval <= 0) {
+        // As an extension, treat nonpositive swap interval as speed multiplier.
+        if (out_speed_scale) {
+            *out_speed_scale = 2.f * static_cast<f32>(1 - swap_interval);
+        }
+
+        swap_interval = 1;
+    }
+
+    if (swap_interval >= 5) {
+        // As an extension, treat high swap interval as precise speed control.
+        if (out_speed_scale) {
+            *out_speed_scale = static_cast<f32>(swap_interval) / 100.f;
+        }
+
+        swap_interval = 1;
+    }
+
+    return swap_interval;
+}
+
+} // namespace
+
+HardwareComposer::HardwareComposer() = default;
+HardwareComposer::~HardwareComposer() = default;
+
+u32 HardwareComposer::ComposeLocked(f32* out_speed_scale, VI::Display& display,
+                                    Nvidia::Devices::nvdisp_disp0& nvdisp, u32 frame_advance) {
+    boost::container::small_vector<HwcLayer, 2> composition_stack;
+
+    m_frame_number += frame_advance;
+
+    // Release any necessary framebuffers.
+    for (auto& [layer_id, framebuffer] : m_framebuffers) {
+        if (framebuffer.release_frame_number > m_frame_number) {
+            // Not yet ready to release this framebuffer.
+            continue;
+        }
+
+        if (!framebuffer.is_acquired) {
+            // Already released.
+            continue;
+        }
+
+        if (auto* layer = display.FindLayer(layer_id); layer != nullptr) {
+            // TODO: support release fence
+            // This is needed to prevent screen tearing
+            layer->GetConsumer().ReleaseBuffer(framebuffer.item, android::Fence::NoFence());
+            framebuffer.is_acquired = false;
+        }
+    }
+
+    // Set default speed limit to 100%.
+    *out_speed_scale = 1.0f;
+
+    // Determine the number of vsync periods to wait before composing again.
+    std::optional<s32> swap_interval{};
+    bool has_acquired_buffer{};
+
+    // Acquire all necessary framebuffers.
+    for (size_t i = 0; i < display.GetNumLayers(); i++) {
+        auto& layer = display.GetLayer(i);
+        auto layer_id = layer.GetLayerId();
+
+        // Try to fetch the framebuffer (either new or stale).
+        const auto result = this->CacheFramebufferLocked(layer, layer_id);
+
+        // If we failed, skip this layer.
+        if (result == CacheStatus::NoBufferAvailable) {
+            continue;
+        }
+
+        // If we acquired a new buffer, we need to present.
+        if (result == CacheStatus::BufferAcquired) {
+            has_acquired_buffer = true;
+        }
+
+        const auto& buffer = m_framebuffers[layer_id];
+        const auto& item = buffer.item;
+        const auto& igbp_buffer = *item.graphic_buffer;
+
+        // TODO: get proper Z-index from layer
+        composition_stack.emplace_back(HwcLayer{
+            .buffer_handle = igbp_buffer.BufferId(),
+            .offset = igbp_buffer.Offset(),
+            .format = igbp_buffer.ExternalFormat(),
+            .width = igbp_buffer.Width(),
+            .height = igbp_buffer.Height(),
+            .stride = igbp_buffer.Stride(),
+            .z_index = 0,
+            .transform = static_cast<android::BufferTransformFlags>(item.transform),
+            .crop_rect = item.crop,
+            .acquire_fence = item.fence,
+        });
+
+        // We need to compose again either before this frame is supposed to
+        // be released, or exactly on the vsync period it should be released.
+        const s32 item_swap_interval = NormalizeSwapInterval(out_speed_scale, item.swap_interval);
+
+        // TODO: handle cases where swap intervals are relatively prime. So far,
+        // only swap intervals of 0, 1 and 2 have been observed, but if 3 were
+        // to be introduced, this would cause an issue.
+        if (swap_interval) {
+            swap_interval = std::min(*swap_interval, item_swap_interval);
+        } else {
+            swap_interval = item_swap_interval;
+        }
+    }
+
+    // If any new buffers were acquired, we can present.
+    if (has_acquired_buffer) {
+        // Sort by Z-index.
+        std::stable_sort(composition_stack.begin(), composition_stack.end(),
+                         [&](auto& l, auto& r) { return l.z_index < r.z_index; });
+
+        // Composite.
+        nvdisp.Composite(composition_stack);
+    }
+
+    // Render MicroProfile.
+    MicroProfileFlip();
+
+    // Advance by at least one frame.
+    return swap_interval.value_or(1);
+}
+
+void HardwareComposer::RemoveLayerLocked(VI::Display& display, LayerId layer_id) {
+    // Check if we are tracking a slot with this layer_id.
+    const auto it = m_framebuffers.find(layer_id);
+    if (it == m_framebuffers.end()) {
+        return;
+    }
+
+    // Try to release the buffer item.
+    auto* const layer = display.FindLayer(layer_id);
+    if (layer && it->second.is_acquired) {
+        layer->GetConsumer().ReleaseBuffer(it->second.item, android::Fence::NoFence());
+    }
+
+    // Erase the slot.
+    m_framebuffers.erase(it);
+}
+
+bool HardwareComposer::TryAcquireFramebufferLocked(VI::Layer& layer, Framebuffer& framebuffer) {
+    // Attempt the update.
+    const auto status = layer.GetConsumer().AcquireBuffer(&framebuffer.item, {}, false);
+    if (status != android::Status::NoError) {
+        return false;
+    }
+
+    // We succeeded, so set the new release frame info.
+    framebuffer.release_frame_number =
+        NormalizeSwapInterval(nullptr, framebuffer.item.swap_interval);
+    framebuffer.is_acquired = true;
+
+    return true;
+}
+
+HardwareComposer::CacheStatus HardwareComposer::CacheFramebufferLocked(VI::Layer& layer,
+                                                                       LayerId layer_id) {
+    // Check if this framebuffer is already present.
+    const auto it = m_framebuffers.find(layer_id);
+    if (it != m_framebuffers.end()) {
+        // If it's currently still acquired, we are done.
+        if (it->second.is_acquired) {
+            return CacheStatus::CachedBufferReused;
+        }
+
+        // Try to acquire a new item.
+        if (this->TryAcquireFramebufferLocked(layer, it->second)) {
+            // We got a new item.
+            return CacheStatus::BufferAcquired;
+        } else {
+            // We didn't acquire a new item, but we can reuse the slot.
+            return CacheStatus::CachedBufferReused;
+        }
+    }
+
+    // Framebuffer is not present, so try to create it.
+    Framebuffer framebuffer{};
+
+    if (this->TryAcquireFramebufferLocked(layer, framebuffer)) {
+        // Move the buffer item into a new slot.
+        m_framebuffers.emplace(layer_id, std::move(framebuffer));
+
+        // We succeeded.
+        return CacheStatus::BufferAcquired;
+    }
+
+    // We couldn't acquire the buffer item, so don't create a slot.
+    return CacheStatus::NoBufferAvailable;
+}
+
+} // namespace Service::Nvnflinger

src/core/hle/service/nvnflinger/hardware_composer.h

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <boost/container/flat_map.hpp>
+
+#include "core/hle/service/nvnflinger/buffer_item.h"
+
+namespace Service::Nvidia::Devices {
+class nvdisp_disp0;
+}
+
+namespace Service::VI {
+class Display;
+class Layer;
+} // namespace Service::VI
+
+namespace Service::Nvnflinger {
+
+using LayerId = u64;
+
+class HardwareComposer {
+public:
+    explicit HardwareComposer();
+    ~HardwareComposer();
+
+    u32 ComposeLocked(f32* out_speed_scale, VI::Display& display,
+                      Nvidia::Devices::nvdisp_disp0& nvdisp, u32 frame_advance);
+    void RemoveLayerLocked(VI::Display& display, LayerId layer_id);
+
+private:
+    // TODO: do we want to track frame number in vi instead?
+    u64 m_frame_number{0};
+
+private:
+    using ReleaseFrameNumber = u64;
+
+    struct Framebuffer {
+        android::BufferItem item{};
+        ReleaseFrameNumber release_frame_number{};
+        bool is_acquired{false};
+    };
+
+    enum class CacheStatus : u32 {
+        NoBufferAvailable,
+        BufferAcquired,
+        CachedBufferReused,
+    };
+
+    boost::container::flat_map<LayerId, Framebuffer> m_framebuffers{};
+
+private:
+    bool TryAcquireFramebufferLocked(VI::Layer& layer, Framebuffer& framebuffer);
+    CacheStatus CacheFramebufferLocked(VI::Layer& layer, LayerId layer_id);
+};
+
+} // namespace Service::Nvnflinger

src/core/hle/service/nvnflinger/hwc_layer.h

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "common/math_util.h"
+#include "core/hle/service/nvdrv/nvdata.h"
+#include "core/hle/service/nvnflinger/buffer_transform_flags.h"
+#include "core/hle/service/nvnflinger/pixel_format.h"
+#include "core/hle/service/nvnflinger/ui/fence.h"
+
+namespace Service::Nvnflinger {
+
+struct HwcLayer {
+    u32 buffer_handle;
+    u32 offset;
+    android::PixelFormat format;
+    u32 width;
+    u32 height;
+    u32 stride;
+    s32 z_index;
+    android::BufferTransformFlags transform;
+    Common::Rectangle<int> crop_rect;
+    android::Fence acquire_fence;
+};
+
+} // namespace Service::Nvnflinger

src/core/hle/service/nvnflinger/nvnflinger.cpp

@@ -18,6 +18,7 @@
 #include "core/hle/service/nvnflinger/buffer_item_consumer.h"
 #include "core/hle/service/nvnflinger/buffer_queue_core.h"
 #include "core/hle/service/nvnflinger/fb_share_buffer_manager.h"
+#include "core/hle/service/nvnflinger/hardware_composer.h"
 #include "core/hle/service/nvnflinger/hos_binder_driver_server.h"
 #include "core/hle/service/nvnflinger/nvnflinger.h"
 #include "core/hle/service/nvnflinger/ui/graphic_buffer.h"
@@ -279,45 +280,19 @@ void Nvnflinger::Compose() {
         SCOPE_EXIT({ display.SignalVSyncEvent(); });
 
         // Don't do anything for displays without layers.
-        if (!display.HasLayers())
-            continue;
-
-        // TODO(Subv): Support more than 1 layer.
-        VI::Layer& layer = display.GetLayer(0);
-
-        android::BufferItem buffer{};
-        const auto status = layer.GetConsumer().AcquireBuffer(&buffer, {}, false);
-
-        if (status != android::Status::NoError) {
+        if (!display.HasLayers()) {
             continue;
         }
 
-        const auto& igbp_buffer = *buffer.graphic_buffer;
-
         if (!system.IsPoweredOn()) {
             return; // We are likely shutting down
         }
 
-        // Now send the buffer to the GPU for drawing.
-        // TODO(Subv): Support more than just disp0. The display device selection is probably based
-        // on which display we're drawing (Default, Internal, External, etc)
         auto nvdisp = nvdrv->GetDevice<Nvidia::Devices::nvdisp_disp0>(disp_fd);
         ASSERT(nvdisp);
 
-        Common::Rectangle<int> crop_rect{
-            static_cast<int>(buffer.crop.Left()), static_cast<int>(buffer.crop.Top()),
-            static_cast<int>(buffer.crop.Right()), static_cast<int>(buffer.crop.Bottom())};
-
-        nvdisp->flip(igbp_buffer.BufferId(), igbp_buffer.Offset(), igbp_buffer.ExternalFormat(),
-                     igbp_buffer.Width(), igbp_buffer.Height(), igbp_buffer.Stride(),
-                     static_cast<android::BufferTransformFlags>(buffer.transform), crop_rect,
-                     buffer.fence.fences, buffer.fence.num_fences);
-
-        MicroProfileFlip();
-
-        swap_interval = buffer.swap_interval;
-
-        layer.GetConsumer().ReleaseBuffer(buffer, android::Fence::NoFence());
+        swap_interval = display.GetComposer().ComposeLocked(&compose_speed_scale, display, *nvdisp,
+                                                            swap_interval);
     }
 }
 
@@ -334,15 +309,16 @@ s64 Nvnflinger::GetNextTicks() const {
             speed_scale = 0.01f;
         }
     }
+
+    // Adjust by speed limit determined during composition.
+    speed_scale /= compose_speed_scale;
+
     if (system.GetNVDECActive() && settings.use_video_framerate.GetValue()) {
         // Run at intended presentation rate during video playback.
         speed_scale = 1.f;
     }
 
-    // As an extension, treat nonpositive swap interval as framerate multiplier.
-    const f32 effective_fps = swap_interval <= 0 ? 120.f * static_cast<f32>(1 - swap_interval)
-                                                 : 60.f / static_cast<f32>(swap_interval);
-
+    const f32 effective_fps = 60.f / static_cast<f32>(swap_interval);
     return static_cast<s64>(speed_scale * (1000000000.f / effective_fps));
 }
 

src/core/hle/service/nvnflinger/nvnflinger.h

@@ -46,6 +46,7 @@ class BufferQueueProducer;
 namespace Service::Nvnflinger {
 
 class FbShareBufferManager;
+class HardwareComposer;
 class HosBinderDriverServer;
 
 class Nvnflinger final {
@@ -143,6 +144,7 @@ private:
     u32 next_buffer_queue_id = 1;
 
     s32 swap_interval = 1;
+    f32 compose_speed_scale = 1.0f;
 
     bool is_abandoned = false;
 

src/core/hle/service/vi/display/vi_display.cpp

@@ -16,6 +16,7 @@
 #include "core/hle/service/nvnflinger/buffer_queue_consumer.h"
 #include "core/hle/service/nvnflinger/buffer_queue_core.h"
 #include "core/hle/service/nvnflinger/buffer_queue_producer.h"
+#include "core/hle/service/nvnflinger/hardware_composer.h"
 #include "core/hle/service/nvnflinger/hos_binder_driver_server.h"
 #include "core/hle/service/vi/display/vi_display.h"
 #include "core/hle/service/vi/layer/vi_layer.h"
@@ -43,6 +44,7 @@ Display::Display(u64 id, std::string name_,
                  KernelHelpers::ServiceContext& service_context_, Core::System& system_)
     : display_id{id}, name{std::move(name_)}, hos_binder_driver_server{hos_binder_driver_server_},
       service_context{service_context_} {
+    hardware_composer = std::make_unique<Nvnflinger::HardwareComposer>();
     vsync_event = service_context.CreateEvent(fmt::format("Display VSync Event {}", id));
 }
 
@@ -81,8 +83,6 @@ void Display::SignalVSyncEvent() {
 
 void Display::CreateLayer(u64 layer_id, u32 binder_id,
                           Service::Nvidia::NvCore::Container& nv_core) {
-    ASSERT_MSG(layers.empty(), "Only one layer is supported per display at the moment");
-
     auto [core, producer, consumer] = CreateBufferQueue(service_context, nv_core.GetNvMapFile());
 
     auto buffer_item_consumer = std::make_shared<android::BufferItemConsumer>(std::move(consumer));

src/core/hle/service/vi/display/vi_display.h

@@ -11,9 +11,14 @@
 #include "common/common_types.h"
 #include "core/hle/result.h"
 
+namespace Core {
+class System;
+}
+
 namespace Kernel {
 class KEvent;
-}
+class KReadableEvent;
+} // namespace Kernel
 
 namespace Service::android {
 class BufferQueueProducer;
@@ -24,8 +29,9 @@ class ServiceContext;
 }
 
 namespace Service::Nvnflinger {
+class HardwareComposer;
 class HosBinderDriverServer;
-}
+} // namespace Service::Nvnflinger
 
 namespace Service::Nvidia::NvCore {
 class Container;
@@ -118,6 +124,10 @@ public:
     ///
     const Layer* FindLayer(u64 layer_id) const;
 
+    Nvnflinger::HardwareComposer& GetComposer() const {
+        return *hardware_composer;
+    }
+
 private:
     u64 display_id;
     std::string name;
@@ -125,6 +135,7 @@ private:
     KernelHelpers::ServiceContext& service_context;
 
     std::vector<std::unique_ptr<Layer>> layers;
+    std::unique_ptr<Nvnflinger::HardwareComposer> hardware_composer;
     Kernel::KEvent* vsync_event{};
     bool is_abandoned{};
 };

src/core/hle/service/vi/vi.cpp

@@ -195,8 +195,9 @@ private:
     void GetSharedBufferMemoryHandleId(HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         const u64 buffer_id = rp.PopRaw<u64>();
+        const u64 aruid = ctx.GetPID();
 
-        LOG_INFO(Service_VI, "called. buffer_id={:#x}", buffer_id);
+        LOG_INFO(Service_VI, "called. buffer_id={:#x}, aruid={:#x}", buffer_id, aruid);
 
         struct OutputParameters {
             s32 nvmap_handle;
@@ -206,7 +207,7 @@ private:
         OutputParameters out{};
         Nvnflinger::SharedMemoryPoolLayout layout{};
         const auto result = nvnflinger.GetSystemBufferManager().GetSharedBufferMemoryHandleId(
-            &out.size, &out.nvmap_handle, &layout, buffer_id, 0);
+            &out.size, &out.nvmap_handle, &layout, buffer_id, aruid);
 
         ctx.WriteBuffer(&layout, sizeof(layout));
 

src/hid_core/resource_manager.cpp

@@ -52,9 +52,42 @@ ResourceManager::ResourceManager(Core::System& system_,
                                  std::shared_ptr<HidFirmwareSettings> settings)
     : firmware_settings{settings}, system{system_}, service_context{system_, "hid"} {
     applet_resource = std::make_shared<AppletResource>(system);
+
+    // Register update callbacks
+    npad_update_event = Core::Timing::CreateEvent("HID::UpdatePadCallback",
+                                                  [this](s64 time, std::chrono::nanoseconds ns_late)
+                                                      -> std::optional<std::chrono::nanoseconds> {
+                                                      UpdateNpad(ns_late);
+                                                      return std::nullopt;
+                                                  });
+    default_update_event = Core::Timing::CreateEvent(
+        "HID::UpdateDefaultCallback",
+        [this](s64 time,
+               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+            UpdateControllers(ns_late);
+            return std::nullopt;
+        });
+    mouse_keyboard_update_event = Core::Timing::CreateEvent(
+        "HID::UpdateMouseKeyboardCallback",
+        [this](s64 time,
+               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+            UpdateMouseKeyboard(ns_late);
+            return std::nullopt;
+        });
+    motion_update_event = Core::Timing::CreateEvent(
+        "HID::UpdateMotionCallback",
+        [this](s64 time,
+               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+            UpdateMotion(ns_late);
+            return std::nullopt;
+        });
 }
 
 ResourceManager::~ResourceManager() {
+    system.CoreTiming().UnscheduleEvent(npad_update_event);
+    system.CoreTiming().UnscheduleEvent(default_update_event);
+    system.CoreTiming().UnscheduleEvent(mouse_keyboard_update_event);
+    system.CoreTiming().UnscheduleEvent(motion_update_event);
     system.CoreTiming().UnscheduleEvent(touch_update_event);
     input_event->Finalize();
 };
@@ -201,6 +234,7 @@ void ResourceManager::InitializeHidCommonSampler() {
 
     debug_pad->SetAppletResource(applet_resource, &shared_mutex);
     digitizer->SetAppletResource(applet_resource, &shared_mutex);
+    unique_pad->SetAppletResource(applet_resource, &shared_mutex);
     keyboard->SetAppletResource(applet_resource, &shared_mutex);
 
     const auto settings =
@@ -214,6 +248,14 @@ void ResourceManager::InitializeHidCommonSampler() {
     home_button->SetAppletResource(applet_resource, &shared_mutex);
     sleep_button->SetAppletResource(applet_resource, &shared_mutex);
     capture_button->SetAppletResource(applet_resource, &shared_mutex);
+
+    system.CoreTiming().ScheduleLoopingEvent(npad_update_ns, npad_update_ns, npad_update_event);
+    system.CoreTiming().ScheduleLoopingEvent(default_update_ns, default_update_ns,
+                                             default_update_event);
+    system.CoreTiming().ScheduleLoopingEvent(mouse_keyboard_update_ns, mouse_keyboard_update_ns,
+                                             mouse_keyboard_update_event);
+    system.CoreTiming().ScheduleLoopingEvent(motion_update_ns, motion_update_ns,
+                                             motion_update_event);
 }
 
 void ResourceManager::InitializeTouchScreenSampler() {
@@ -465,55 +507,9 @@ IAppletResource::IAppletResource(Core::System& system_, std::shared_ptr<Resource
         {0, &IAppletResource::GetSharedMemoryHandle, "GetSharedMemoryHandle"},
     };
     RegisterHandlers(functions);
-
-    // Register update callbacks
-    npad_update_event = Core::Timing::CreateEvent(
-        "HID::UpdatePadCallback",
-        [this, resource](
-            s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            const auto guard = LockService();
-            resource->UpdateNpad(ns_late);
-            return std::nullopt;
-        });
-    default_update_event = Core::Timing::CreateEvent(
-        "HID::UpdateDefaultCallback",
-        [this, resource](
-            s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            const auto guard = LockService();
-            resource->UpdateControllers(ns_late);
-            return std::nullopt;
-        });
-    mouse_keyboard_update_event = Core::Timing::CreateEvent(
-        "HID::UpdateMouseKeyboardCallback",
-        [this, resource](
-            s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            const auto guard = LockService();
-            resource->UpdateMouseKeyboard(ns_late);
-            return std::nullopt;
-        });
-    motion_update_event = Core::Timing::CreateEvent(
-        "HID::UpdateMotionCallback",
-        [this, resource](
-            s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            const auto guard = LockService();
-            resource->UpdateMotion(ns_late);
-            return std::nullopt;
-        });
-
-    system.CoreTiming().ScheduleLoopingEvent(npad_update_ns, npad_update_ns, npad_update_event);
-    system.CoreTiming().ScheduleLoopingEvent(default_update_ns, default_update_ns,
-                                             default_update_event);
-    system.CoreTiming().ScheduleLoopingEvent(mouse_keyboard_update_ns, mouse_keyboard_update_ns,
-                                             mouse_keyboard_update_event);
-    system.CoreTiming().ScheduleLoopingEvent(motion_update_ns, motion_update_ns,
-                                             motion_update_event);
 }
 
 IAppletResource::~IAppletResource() {
-    system.CoreTiming().UnscheduleEvent(npad_update_event);
-    system.CoreTiming().UnscheduleEvent(default_update_event);
-    system.CoreTiming().UnscheduleEvent(mouse_keyboard_update_event);
-    system.CoreTiming().UnscheduleEvent(motion_update_event);
     resource_manager->FreeAppletResourceId(aruid);
 }
 

src/hid_core/resource_manager.h

@@ -147,6 +147,10 @@ private:
     std::shared_ptr<SixAxis> six_axis{nullptr};
     std::shared_ptr<SleepButton> sleep_button{nullptr};
     std::shared_ptr<UniquePad> unique_pad{nullptr};
+    std::shared_ptr<Core::Timing::EventType> npad_update_event;
+    std::shared_ptr<Core::Timing::EventType> default_update_event;
+    std::shared_ptr<Core::Timing::EventType> mouse_keyboard_update_event;
+    std::shared_ptr<Core::Timing::EventType> motion_update_event;
 
     // TODO: Create these resources
     // std::shared_ptr<AudioControl> audio_control{nullptr};
@@ -179,11 +183,6 @@ public:
 private:
     void GetSharedMemoryHandle(HLERequestContext& ctx);
 
-    std::shared_ptr<Core::Timing::EventType> npad_update_event{nullptr};
-    std::shared_ptr<Core::Timing::EventType> default_update_event{nullptr};
-    std::shared_ptr<Core::Timing::EventType> mouse_keyboard_update_event{nullptr};
-    std::shared_ptr<Core::Timing::EventType> motion_update_event{nullptr};
-
     u64 aruid{};
     std::shared_ptr<ResourceManager> resource_manager;
 };

src/hid_core/resources/digitizer/digitizer.cpp

@@ -17,10 +17,6 @@ void Digitizer::OnInit() {}
 void Digitizer::OnRelease() {}
 
 void Digitizer::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
-    if (!smart_update) {
-        return;
-    }
-
     std::scoped_lock shared_lock{*shared_mutex};
     const u64 aruid = applet_resource->GetActiveAruid();
     auto* data = applet_resource->GetAruidData(aruid);

src/hid_core/resources/digitizer/digitizer.h

@@ -20,8 +20,5 @@ public:
 
     // When the controller is requesting an update for the shared memory
     void OnUpdate(const Core::Timing::CoreTiming& core_timing) override;
-
-private:
-    bool smart_update{};
 };
 } // namespace Service::HID

src/hid_core/resources/npad/npad.cpp

@@ -102,6 +102,8 @@ Result NPad::Activate(u64 aruid) {
         for (std::size_t i = 0; i < 19; ++i) {
             WriteEmptyEntry(npad);
         }
+
+        controller.is_active = true;
     }
 
     return ResultSuccess;
@@ -467,6 +469,13 @@ void NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
             continue;
         }
 
+        bool is_set{};
+        npad_resource.IsSupportedNpadStyleSet(is_set, aruid);
+        // Wait until style is defined
+        if (!is_set) {
+            continue;
+        }
+
         for (std::size_t i = 0; i < controller_data[aruid_index].size(); ++i) {
             auto& controller = controller_data[aruid_index][i];
             controller.shared_memory =
@@ -484,6 +493,10 @@ void NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
                 continue;
             }
 
+            if (!controller.is_active) {
+                continue;
+            }
+
             RequestPadStateUpdate(aruid, controller.device->GetNpadIdType());
             auto& pad_state = controller.npad_pad_state;
             auto& libnx_state = controller.npad_libnx_state;
@@ -592,7 +605,9 @@ void NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
             libnx_state.npad_buttons.raw = pad_state.npad_buttons.raw;
             libnx_state.l_stick = pad_state.l_stick;
             libnx_state.r_stick = pad_state.r_stick;
-            npad->system_ext_lifo.WriteNextEntry(pad_state);
+            libnx_state.sampling_number =
+                npad->system_ext_lifo.ReadCurrentEntry().state.sampling_number + 1;
+            npad->system_ext_lifo.WriteNextEntry(libnx_state);
 
             press_state |= static_cast<u64>(pad_state.npad_buttons.raw);
         }
@@ -1060,6 +1075,7 @@ void NPad::UnregisterAppletResourceUserId(u64 aruid) {
     // TODO: Remove this once abstract pad is emulated properly
     const auto aruid_index = npad_resource.GetIndexFromAruid(aruid);
     for (auto& controller : controller_data[aruid_index]) {
+        controller.is_active = false;
         controller.is_connected = false;
         controller.shared_memory = nullptr;
     }

src/hid_core/resources/npad/npad.h

@@ -164,6 +164,7 @@ private:
         NpadInternalState* shared_memory = nullptr;
         Core::HID::EmulatedController* device = nullptr;
 
+        bool is_active{};
         bool is_connected{};
 
         // Dual joycons can have only one side connected

src/hid_core/resources/unique_pad/unique_pad.cpp

@@ -17,10 +17,6 @@ void UniquePad::OnInit() {}
 void UniquePad::OnRelease() {}
 
 void UniquePad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
-    if (!smart_update) {
-        return;
-    }
-
     const u64 aruid = applet_resource->GetActiveAruid();
     auto* data = applet_resource->GetAruidData(aruid);
 

src/hid_core/resources/unique_pad/unique_pad.h

@@ -20,8 +20,5 @@ public:
 
     // When the controller is requesting an update for the shared memory
     void OnUpdate(const Core::Timing::CoreTiming& core_timing) override;
-
-private:
-    bool smart_update{};
 };
 } // namespace Service::HID

src/video_core/CMakeLists.txt

@@ -55,6 +55,7 @@ add_library(video_core STATIC
     engines/maxwell_dma.h
     engines/puller.cpp
     engines/puller.h
+    framebuffer_config.cpp
     framebuffer_config.h
     fsr.cpp
     fsr.h
@@ -115,8 +116,24 @@ add_library(video_core STATIC
     renderer_null/null_rasterizer.h
     renderer_null/renderer_null.cpp
     renderer_null/renderer_null.h
+    renderer_opengl/present/filters.cpp
+    renderer_opengl/present/filters.h
+    renderer_opengl/present/fsr.cpp
+    renderer_opengl/present/fsr.h
+    renderer_opengl/present/fxaa.cpp
+    renderer_opengl/present/fxaa.h
+    renderer_opengl/present/layer.cpp
+    renderer_opengl/present/layer.h
+    renderer_opengl/present/present_uniforms.h
+    renderer_opengl/present/smaa.cpp
+    renderer_opengl/present/smaa.h
+    renderer_opengl/present/util.h
+    renderer_opengl/present/window_adapt_pass.cpp
+    renderer_opengl/present/window_adapt_pass.h
     renderer_opengl/blit_image.cpp
     renderer_opengl/blit_image.h
+    renderer_opengl/gl_blit_screen.cpp
+    renderer_opengl/gl_blit_screen.h
     renderer_opengl/gl_buffer_cache_base.cpp
     renderer_opengl/gl_buffer_cache.cpp
     renderer_opengl/gl_buffer_cache.h
@@ -126,8 +143,6 @@ add_library(video_core STATIC
     renderer_opengl/gl_device.h
     renderer_opengl/gl_fence_manager.cpp
     renderer_opengl/gl_fence_manager.h
-    renderer_opengl/gl_fsr.cpp
-    renderer_opengl/gl_fsr.h
     renderer_opengl/gl_graphics_pipeline.cpp
     renderer_opengl/gl_graphics_pipeline.h
     renderer_opengl/gl_rasterizer.cpp
@@ -155,6 +170,22 @@ add_library(video_core STATIC
     renderer_opengl/renderer_opengl.h
     renderer_opengl/util_shaders.cpp
     renderer_opengl/util_shaders.h
+    renderer_vulkan/present/anti_alias_pass.h
+    renderer_vulkan/present/filters.cpp
+    renderer_vulkan/present/filters.h
+    renderer_vulkan/present/fsr.cpp
+    renderer_vulkan/present/fsr.h
+    renderer_vulkan/present/fxaa.cpp
+    renderer_vulkan/present/fxaa.h
+    renderer_vulkan/present/layer.cpp
+    renderer_vulkan/present/layer.h
+    renderer_vulkan/present/present_push_constants.h
+    renderer_vulkan/present/smaa.cpp
+    renderer_vulkan/present/smaa.h
+    renderer_vulkan/present/util.cpp
+    renderer_vulkan/present/util.h
+    renderer_vulkan/present/window_adapt_pass.cpp
+    renderer_vulkan/present/window_adapt_pass.h
     renderer_vulkan/blit_image.cpp
     renderer_vulkan/blit_image.h
     renderer_vulkan/fixed_pipeline_state.cpp
@@ -181,8 +212,6 @@ add_library(video_core STATIC
     renderer_vulkan/vk_descriptor_pool.h
     renderer_vulkan/vk_fence_manager.cpp
     renderer_vulkan/vk_fence_manager.h
-    renderer_vulkan/vk_fsr.cpp
-    renderer_vulkan/vk_fsr.h
     renderer_vulkan/vk_graphics_pipeline.cpp
     renderer_vulkan/vk_graphics_pipeline.h
     renderer_vulkan/vk_master_semaphore.cpp
@@ -203,8 +232,6 @@ add_library(video_core STATIC
     renderer_vulkan/vk_scheduler.h
     renderer_vulkan/vk_shader_util.cpp
     renderer_vulkan/vk_shader_util.h
-    renderer_vulkan/vk_smaa.cpp
-    renderer_vulkan/vk_smaa.h
     renderer_vulkan/vk_staging_buffer_pool.cpp
     renderer_vulkan/vk_staging_buffer_pool.h
     renderer_vulkan/vk_state_tracker.cpp

src/video_core/engines/maxwell_dma.h

@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "common/bit_field.h"
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/scratch_buffer.h"
 #include "video_core/engines/engine_interface.h"

src/video_core/framebuffer_config.cpp

@@ -0,0 +1,55 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/assert.h"
+#include "video_core/framebuffer_config.h"
+
+namespace Tegra {
+
+Common::Rectangle<f32> NormalizeCrop(const FramebufferConfig& framebuffer, u32 texture_width,
+                                     u32 texture_height) {
+    f32 left, top, right, bottom;
+
+    if (!framebuffer.crop_rect.IsEmpty()) {
+        // If crop rectangle is not empty, apply properties from rectangle.
+        left = static_cast<f32>(framebuffer.crop_rect.left);
+        top = static_cast<f32>(framebuffer.crop_rect.top);
+        right = static_cast<f32>(framebuffer.crop_rect.right);
+        bottom = static_cast<f32>(framebuffer.crop_rect.bottom);
+    } else {
+        // Otherwise, fall back to framebuffer dimensions.
+        left = 0;
+        top = 0;
+        right = static_cast<f32>(framebuffer.width);
+        bottom = static_cast<f32>(framebuffer.height);
+    }
+
+    // Apply transformation flags.
+    auto framebuffer_transform_flags = framebuffer.transform_flags;
+
+    if (True(framebuffer_transform_flags & Service::android::BufferTransformFlags::FlipH)) {
+        // Switch left and right.
+        std::swap(left, right);
+    }
+    if (True(framebuffer_transform_flags & Service::android::BufferTransformFlags::FlipV)) {
+        // Switch top and bottom.
+        std::swap(top, bottom);
+    }
+
+    framebuffer_transform_flags &= ~Service::android::BufferTransformFlags::FlipH;
+    framebuffer_transform_flags &= ~Service::android::BufferTransformFlags::FlipV;
+    if (True(framebuffer_transform_flags)) {
+        UNIMPLEMENTED_MSG("Unsupported framebuffer_transform_flags={}",
+                          static_cast<u32>(framebuffer_transform_flags));
+    }
+
+    // Normalize coordinate space.
+    left /= static_cast<f32>(texture_width);
+    top /= static_cast<f32>(texture_height);
+    right /= static_cast<f32>(texture_width);
+    bottom /= static_cast<f32>(texture_height);
+
+    return Common::Rectangle<f32>(left, top, right, bottom);
+}
+
+} // namespace Tegra

src/video_core/framebuffer_config.h

@@ -7,6 +7,7 @@
 #include "common/math_util.h"
 #include "core/hle/service/nvnflinger/buffer_transform_flags.h"
 #include "core/hle/service/nvnflinger/pixel_format.h"
+#include "core/hle/service/nvnflinger/ui/fence.h"
 
 namespace Tegra {
 
@@ -21,7 +22,10 @@ struct FramebufferConfig {
     u32 stride{};
     Service::android::PixelFormat pixel_format{};
     Service::android::BufferTransformFlags transform_flags{};
-    Common::Rectangle<int> crop_rect;
+    Common::Rectangle<int> crop_rect{};
 };
 
+Common::Rectangle<f32> NormalizeCrop(const FramebufferConfig& framebuffer, u32 texture_width,
+                                     u32 texture_height);
+
 } // namespace Tegra

src/video_core/gpu.cpp

@@ -274,11 +274,6 @@ struct GPU::Impl {
         }
     }
 
-    /// Swap buffers (render frame)
-    void SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
-        gpu_thread.SwapBuffers(framebuffer);
-    }
-
     /// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
     void FlushRegion(DAddr addr, u64 size) {
         gpu_thread.FlushRegion(addr, size);
@@ -313,8 +308,9 @@ struct GPU::Impl {
         gpu_thread.FlushAndInvalidateRegion(addr, size);
     }
 
-    void RequestSwapBuffers(const Tegra::FramebufferConfig* framebuffer,
-                            std::array<Service::Nvidia::NvFence, 4>& fences, size_t num_fences) {
+    void RequestComposite(std::vector<Tegra::FramebufferConfig>&& layers,
+                          std::vector<Service::Nvidia::NvFence>&& fences) {
+        size_t num_fences{fences.size()};
         size_t current_request_counter{};
         {
             std::unique_lock<std::mutex> lk(request_swap_mutex);
@@ -328,13 +324,12 @@ struct GPU::Impl {
             }
         }
         const auto wait_fence =
-            RequestSyncOperation([this, current_request_counter, framebuffer, fences, num_fences] {
+            RequestSyncOperation([this, current_request_counter, &layers, &fences, num_fences] {
                 auto& syncpoint_manager = host1x.GetSyncpointManager();
                 if (num_fences == 0) {
-                    renderer->SwapBuffers(framebuffer);
+                    renderer->Composite(layers);
                 }
-                const auto executer = [this, current_request_counter,
-                                       framebuffer_copy = *framebuffer]() {
+                const auto executer = [this, current_request_counter, layers_copy = layers]() {
                     {
                         std::unique_lock<std::mutex> lk(request_swap_mutex);
                         if (--request_swap_counters[current_request_counter] != 0) {
@@ -342,7 +337,7 @@ struct GPU::Impl {
                         }
                         free_swap_counters.push_back(current_request_counter);
                     }
-                    renderer->SwapBuffers(&framebuffer_copy);
+                    renderer->Composite(layers_copy);
                 };
                 for (size_t i = 0; i < num_fences; i++) {
                     syncpoint_manager.RegisterGuestAction(fences[i].id, fences[i].value, executer);
@@ -505,9 +500,9 @@ const VideoCore::ShaderNotify& GPU::ShaderNotify() const {
     return impl->ShaderNotify();
 }
 
-void GPU::RequestSwapBuffers(const Tegra::FramebufferConfig* framebuffer,
-                             std::array<Service::Nvidia::NvFence, 4>& fences, size_t num_fences) {
-    impl->RequestSwapBuffers(framebuffer, fences, num_fences);
+void GPU::RequestComposite(std::vector<Tegra::FramebufferConfig>&& layers,
+                           std::vector<Service::Nvidia::NvFence>&& fences) {
+    impl->RequestComposite(std::move(layers), std::move(fences));
 }
 
 u64 GPU::GetTicks() const {
@@ -554,10 +549,6 @@ void GPU::ClearCdmaInstance(u32 id) {
     impl->ClearCdmaInstance(id);
 }
 
-void GPU::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
-    impl->SwapBuffers(framebuffer);
-}
-
 VideoCore::RasterizerDownloadArea GPU::OnCPURead(PAddr addr, u64 size) {
     return impl->OnCPURead(addr, size);
 }

src/video_core/gpu.h

@@ -212,8 +212,8 @@ public:
 
     void RendererFrameEndNotify();
 
-    void RequestSwapBuffers(const Tegra::FramebufferConfig* framebuffer,
-                            std::array<Service::Nvidia::NvFence, 4>& fences, size_t num_fences);
+    void RequestComposite(std::vector<Tegra::FramebufferConfig>&& layers,
+                          std::vector<Service::Nvidia::NvFence>&& fences);
 
     /// Performs any additional setup necessary in order to begin GPU emulation.
     /// This can be used to launch any necessary threads and register any necessary

src/video_core/gpu_thread.cpp

@@ -40,8 +40,6 @@ static void RunThread(std::stop_token stop_token, Core::System& system,
         }
         if (auto* submit_list = std::get_if<SubmitListCommand>(&next.data)) {
             scheduler.Push(submit_list->channel, std::move(submit_list->entries));
-        } else if (const auto* data = std::get_if<SwapBuffersCommand>(&next.data)) {
-            renderer.SwapBuffers(data->framebuffer ? &*data->framebuffer : nullptr);
         } else if (std::holds_alternative<GPUTickCommand>(next.data)) {
             system.GPU().TickWork();
         } else if (const auto* flush = std::get_if<FlushRegionCommand>(&next.data)) {
@@ -78,10 +76,6 @@ void ThreadManager::SubmitList(s32 channel, Tegra::CommandList&& entries) {
     PushCommand(SubmitListCommand(channel, std::move(entries)));
 }
 
-void ThreadManager::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
-    PushCommand(SwapBuffersCommand(framebuffer ? std::make_optional(*framebuffer) : std::nullopt));
-}
-
 void ThreadManager::FlushRegion(DAddr addr, u64 size) {
     if (!is_async) {
         // Always flush with synchronous GPU mode

src/video_core/gpu_thread.h

@@ -44,14 +44,6 @@ struct SubmitListCommand final {
     Tegra::CommandList entries;
 };
 
-/// Command to signal to the GPU thread that a swap buffers is pending
-struct SwapBuffersCommand final {
-    explicit SwapBuffersCommand(std::optional<const Tegra::FramebufferConfig> framebuffer_)
-        : framebuffer{std::move(framebuffer_)} {}
-
-    std::optional<Tegra::FramebufferConfig> framebuffer;
-};
-
 /// Command to signal to the GPU thread to flush a region
 struct FlushRegionCommand final {
     explicit constexpr FlushRegionCommand(DAddr addr_, u64 size_) : addr{addr_}, size{size_} {}
@@ -81,8 +73,8 @@ struct FlushAndInvalidateRegionCommand final {
 struct GPUTickCommand final {};
 
 using CommandData =
-    std::variant<std::monostate, SubmitListCommand, SwapBuffersCommand, FlushRegionCommand,
-                 InvalidateRegionCommand, FlushAndInvalidateRegionCommand, GPUTickCommand>;
+    std::variant<std::monostate, SubmitListCommand, FlushRegionCommand, InvalidateRegionCommand,
+                 FlushAndInvalidateRegionCommand, GPUTickCommand>;
 
 struct CommandDataContainer {
     CommandDataContainer() = default;
@@ -118,9 +110,6 @@ public:
     /// Push GPU command entries to be processed
     void SubmitList(s32 channel, Tegra::CommandList&& entries);
 
-    /// Swap buffers (render frame)
-    void SwapBuffers(const Tegra::FramebufferConfig* framebuffer);
-
     /// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
     void FlushRegion(DAddr addr, u64 size);
 

src/video_core/host_shaders/CMakeLists.txt

@@ -9,7 +9,7 @@ set(FIDELITYFX_FILES
 )
 
 set(GLSL_INCLUDES
-    fidelityfx_fsr.comp
+    fidelityfx_fsr.frag
     ${FIDELITYFX_FILES}
 )
 
@@ -56,10 +56,11 @@ set(SHADER_FILES
     vulkan_color_clear.frag
     vulkan_color_clear.vert
     vulkan_depthstencil_clear.frag
-    vulkan_fidelityfx_fsr_easu_fp16.comp
-    vulkan_fidelityfx_fsr_easu_fp32.comp
-    vulkan_fidelityfx_fsr_rcas_fp16.comp
-    vulkan_fidelityfx_fsr_rcas_fp32.comp
+    vulkan_fidelityfx_fsr.vert
+    vulkan_fidelityfx_fsr_easu_fp16.frag
+    vulkan_fidelityfx_fsr_easu_fp32.frag
+    vulkan_fidelityfx_fsr_rcas_fp16.frag
+    vulkan_fidelityfx_fsr_rcas_fp32.frag
     vulkan_present.frag
     vulkan_present.vert
     vulkan_present_scaleforce_fp16.frag

src/video_core/host_shaders/fidelityfx_fsr.frag

@@ -0,0 +1,110 @@
+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+//!#version 460 core
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_ARB_shading_language_420pack : enable
+#extension GL_GOOGLE_include_directive : enable
+#extension GL_EXT_shader_explicit_arithmetic_types : require
+
+// FidelityFX Super Resolution Sample
+//
+// Copyright (c) 2021 Advanced Micro Devices, Inc. All rights reserved.
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files(the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+layout( push_constant ) uniform constants {
+    uvec4 Const0;
+    uvec4 Const1;
+    uvec4 Const2;
+    uvec4 Const3;
+};
+
+layout(set=0,binding=0) uniform sampler2D InputTexture;
+
+#define A_GPU 1
+#define A_GLSL 1
+
+#ifndef YUZU_USE_FP16
+    #include "ffx_a.h"
+
+    #if USE_EASU
+        #define FSR_EASU_F 1
+        AF4 FsrEasuRF(AF2 p) { AF4 res = textureGather(InputTexture, p, 0); return res; }
+        AF4 FsrEasuGF(AF2 p) { AF4 res = textureGather(InputTexture, p, 1); return res; }
+        AF4 FsrEasuBF(AF2 p) { AF4 res = textureGather(InputTexture, p, 2); return res; }
+    #endif
+    #if USE_RCAS
+        #define FSR_RCAS_F 1
+        AF4 FsrRcasLoadF(ASU2 p) { return texelFetch(InputTexture, ASU2(p), 0); }
+        void FsrRcasInputF(inout AF1 r, inout AF1 g, inout AF1 b) {}
+    #endif
+#else
+    #define A_HALF
+    #include "ffx_a.h"
+
+    #if USE_EASU
+        #define FSR_EASU_H 1
+        AH4 FsrEasuRH(AF2 p) { AH4 res = AH4(textureGather(InputTexture, p, 0)); return res; }
+        AH4 FsrEasuGH(AF2 p) { AH4 res = AH4(textureGather(InputTexture, p, 1)); return res; }
+        AH4 FsrEasuBH(AF2 p) { AH4 res = AH4(textureGather(InputTexture, p, 2)); return res; }
+    #endif
+    #if USE_RCAS
+        #define FSR_RCAS_H 1
+        AH4 FsrRcasLoadH(ASW2 p) { return AH4(texelFetch(InputTexture, ASU2(p), 0)); }
+        void FsrRcasInputH(inout AH1 r,inout AH1 g,inout AH1 b){}
+    #endif
+#endif
+
+#include "ffx_fsr1.h"
+
+#if USE_RCAS
+    layout(location = 0) in vec2 frag_texcoord;
+#endif
+layout (location = 0) out vec4 frag_color;
+
+void CurrFilter(AU2 pos) {
+#if USE_EASU
+    #ifndef YUZU_USE_FP16
+        AF3 c;
+        FsrEasuF(c, pos, Const0, Const1, Const2, Const3);
+        frag_color = AF4(c, 1.0);
+    #else
+        AH3 c;
+        FsrEasuH(c, pos, Const0, Const1, Const2, Const3);
+        frag_color = AH4(c, 1.0);
+    #endif
+#endif
+#if USE_RCAS
+    #ifndef YUZU_USE_FP16
+        AF3 c;
+        FsrRcasF(c.r, c.g, c.b, pos, Const0);
+        frag_color = AF4(c, 1.0);
+    #else
+        AH3 c;
+        FsrRcasH(c.r, c.g, c.b, pos, Const0);
+        frag_color = AH4(c, 1.0);
+    #endif
+#endif
+}
+
+void main() {
+#if USE_RCAS
+    CurrFilter(AU2(frag_texcoord * vec2(textureSize(InputTexture, 0))));
+#else
+    CurrFilter(AU2(gl_FragCoord.xy));
+#endif
+}

src/video_core/host_shaders/fxaa.vert

@@ -7,8 +7,8 @@ out gl_PerVertex {
     vec4 gl_Position;
 };
 
-const vec2 vertices[4] =
-    vec2[4](vec2(-1.0, 1.0), vec2(1.0, 1.0), vec2(-1.0, -1.0), vec2(1.0, -1.0));
+const vec2 vertices[3] =
+    vec2[3](vec2(-1,-1), vec2(3,-1), vec2(-1, 3));
 
 layout (location = 0) out vec4 posPos;
 

src/video_core/host_shaders/opengl_present_scaleforce.frag

@@ -26,21 +26,11 @@
 
 #endif
 
-#ifdef VULKAN
-
-#define BINDING_COLOR_TEXTURE 1
-
-#else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
-
-#define BINDING_COLOR_TEXTURE 0
-
-#endif
-
 layout (location = 0) in vec2 tex_coord;
 
 layout (location = 0) out vec4 frag_color;
 
-layout (binding = BINDING_COLOR_TEXTURE) uniform sampler2D input_texture;
+layout (binding = 0) uniform sampler2D input_texture;
 
 const bool ignore_alpha = true;
 

src/video_core/host_shaders/present_bicubic.frag

@@ -3,22 +3,12 @@
 
 #version 460 core
 
-#ifdef VULKAN
-
-#define BINDING_COLOR_TEXTURE 1
-
-#else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
-
-#define BINDING_COLOR_TEXTURE 0
-
-#endif
-
 
 layout (location = 0) in vec2 frag_tex_coord;
 
 layout (location = 0) out vec4 color;
 
-layout (binding = BINDING_COLOR_TEXTURE) uniform sampler2D color_texture;
+layout (binding = 0) uniform sampler2D color_texture;
 
 vec4 cubic(float v) {
     vec4 n = vec4(1.0, 2.0, 3.0, 4.0) - v;

src/video_core/host_shaders/present_gaussian.frag

@@ -7,21 +7,11 @@
 
 #version 460 core
 
-#ifdef VULKAN
-
-#define BINDING_COLOR_TEXTURE 1
-
-#else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
-
-#define BINDING_COLOR_TEXTURE 0
-
-#endif
-
 layout(location = 0) in vec2 frag_tex_coord;
 
 layout(location = 0) out vec4 color;
 
-layout(binding = BINDING_COLOR_TEXTURE) uniform sampler2D color_texture;
+layout(binding = 0) uniform sampler2D color_texture;
 
 const float offset[3] = float[](0.0, 1.3846153846, 3.2307692308);
 const float weight[3] = float[](0.2270270270, 0.3162162162, 0.0702702703);

src/video_core/host_shaders/vulkan_fidelityfx_fsr.vert

@@ -0,0 +1,13 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 450
+
+layout(location = 0) out vec2 texcoord;
+
+void main() {
+    float x = float((gl_VertexIndex & 1) << 2);
+    float y = float((gl_VertexIndex & 2) << 1);
+    gl_Position = vec4(x - 1.0, y - 1.0, 0.0, 1.0);
+    texcoord = vec2(x, y) / 2.0;
+}

src/video_core/host_shaders/vulkan_fidelityfx_fsr_easu_fp16.frag

@@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 460 core
+#extension GL_GOOGLE_include_directive : enable
+
+#define YUZU_USE_FP16
+#define USE_EASU 1
+
+#include "fidelityfx_fsr.frag"

src/video_core/host_shaders/vulkan_fidelityfx_fsr_easu_fp32.frag

@@ -0,0 +1,9 @@
+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 460 core
+#extension GL_GOOGLE_include_directive : enable
+
+#define USE_EASU 1
+
+#include "fidelityfx_fsr.frag"

src/video_core/host_shaders/vulkan_fidelityfx_fsr_rcas_fp16.frag

@@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 460 core
+#extension GL_GOOGLE_include_directive : enable
+
+#define YUZU_USE_FP16
+#define USE_RCAS 1
+
+#include "fidelityfx_fsr.frag"

src/video_core/host_shaders/vulkan_fidelityfx_fsr_rcas_fp32.frag

@@ -0,0 +1,9 @@
+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 460 core
+#extension GL_GOOGLE_include_directive : enable
+
+#define USE_RCAS 1
+
+#include "fidelityfx_fsr.frag"

src/video_core/host_shaders/vulkan_present.frag

@@ -7,7 +7,7 @@ layout (location = 0) in vec2 frag_tex_coord;
 
 layout (location = 0) out vec4 color;
 
-layout (binding = 1) uniform sampler2D color_texture;
+layout (binding = 0) uniform sampler2D color_texture;
 
 void main() {
     color = texture(color_texture, frag_tex_coord);

src/video_core/host_shaders/vulkan_present.vert

@@ -3,16 +3,37 @@
 
 #version 460 core
 
-layout (location = 0) in vec2 vert_position;
-layout (location = 1) in vec2 vert_tex_coord;
-
 layout (location = 0) out vec2 frag_tex_coord;
 
-layout (set = 0, binding = 0) uniform MatrixBlock {
-    mat4 modelview_matrix;
+struct ScreenRectVertex {
+    vec2 position;
+    vec2 tex_coord;
 };
 
-void main() {
-    gl_Position = modelview_matrix * vec4(vert_position, 0.0, 1.0);
-    frag_tex_coord = vert_tex_coord;
+layout (push_constant) uniform PushConstants {
+    mat4 modelview_matrix;
+    ScreenRectVertex vertices[4];
+};
+
+// Vulkan spec 15.8.1:
+//   Any member of a push constant block that is declared as an
+//   array must only be accessed with dynamically uniform indices.
+ScreenRectVertex GetVertex(int index) {
+    switch (index) {
+    case 0:
+    default:
+        return vertices[0];
+    case 1:
+        return vertices[1];
+    case 2:
+        return vertices[2];
+    case 3:
+        return vertices[3];
+    }
+}
+
+void main() {
+    ScreenRectVertex vertex = GetVertex(gl_VertexIndex);
+    gl_Position = modelview_matrix * vec4(vertex.position, 0.0, 1.0);
+    frag_tex_coord = vertex.tex_coord;
 }

src/video_core/host_shaders/vulkan_present_scaleforce_fp16.frag

@@ -5,6 +5,7 @@
 
 #extension GL_GOOGLE_include_directive : enable
 
+#define VERSION 1
 #define YUZU_USE_FP16
 
 #include "opengl_present_scaleforce.frag"

src/video_core/host_shaders/vulkan_present_scaleforce_fp32.frag

@@ -5,4 +5,6 @@
 
 #extension GL_GOOGLE_include_directive : enable
 
+#define VERSION 1
+
 #include "opengl_present_scaleforce.frag"

src/video_core/rasterizer_interface.h

@@ -155,12 +155,6 @@ public:
     virtual void AccelerateInlineToMemory(GPUVAddr address, size_t copy_size,
                                           std::span<const u8> memory) = 0;
 
-    /// Attempt to use a faster method to display the framebuffer to screen
-    [[nodiscard]] virtual bool AccelerateDisplay(const Tegra::FramebufferConfig& config,
-                                                 DAddr framebuffer_addr, u32 pixel_stride) {
-        return false;
-    }
-
     /// Initialize disk cached resources for the game being emulated
     virtual void LoadDiskResources(u64 title_id, std::stop_token stop_loading,
                                    const DiskResourceLoadCallback& callback) {}

src/video_core/renderer_base.h

@@ -38,7 +38,7 @@ public:
     virtual ~RendererBase();
 
     /// Finalize rendering the guest frame and draw into the presentation texture
-    virtual void SwapBuffers(const Tegra::FramebufferConfig* framebuffer) = 0;
+    virtual void Composite(std::span<const Tegra::FramebufferConfig> layers) = 0;
 
     [[nodiscard]] virtual RasterizerInterface* ReadRasterizer() = 0;
 

src/video_core/renderer_null/null_rasterizer.cpp

@@ -92,10 +92,6 @@ bool RasterizerNull::AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Surfac
 }
 void RasterizerNull::AccelerateInlineToMemory(GPUVAddr address, size_t copy_size,
                                               std::span<const u8> memory) {}
-bool RasterizerNull::AccelerateDisplay(const Tegra::FramebufferConfig& config,
-                                       DAddr framebuffer_addr, u32 pixel_stride) {
-    return true;
-}
 void RasterizerNull::LoadDiskResources(u64 title_id, std::stop_token stop_loading,
                                        const VideoCore::DiskResourceLoadCallback& callback) {}
 void RasterizerNull::InitializeChannel(Tegra::Control::ChannelState& channel) {

src/video_core/renderer_null/null_rasterizer.h

@@ -77,8 +77,6 @@ public:
     Tegra::Engines::AccelerateDMAInterface& AccessAccelerateDMA() override;
     void AccelerateInlineToMemory(GPUVAddr address, size_t copy_size,
                                   std::span<const u8> memory) override;
-    bool AccelerateDisplay(const Tegra::FramebufferConfig& config, DAddr framebuffer_addr,
-                           u32 pixel_stride) override;
     void LoadDiskResources(u64 title_id, std::stop_token stop_loading,
                            const VideoCore::DiskResourceLoadCallback& callback) override;
     void InitializeChannel(Tegra::Control::ChannelState& channel) override;

src/video_core/renderer_null/renderer_null.cpp

@@ -13,8 +13,8 @@ RendererNull::RendererNull(Core::Frontend::EmuWindow& emu_window, Tegra::GPU& gp
 
 RendererNull::~RendererNull() = default;
 
-void RendererNull::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
-    if (!framebuffer) {
+void RendererNull::Composite(std::span<const Tegra::FramebufferConfig> framebuffers) {
+    if (framebuffers.empty()) {
         return;
     }
 

src/video_core/renderer_null/renderer_null.h

@@ -17,7 +17,7 @@ public:
                           std::unique_ptr<Core::Frontend::GraphicsContext> context);
     ~RendererNull() override;
 
-    void SwapBuffers(const Tegra::FramebufferConfig* framebuffer) override;
+    void Composite(std::span<const Tegra::FramebufferConfig> framebuffer) override;
 
     VideoCore::RasterizerInterface* ReadRasterizer() override {
         return &m_rasterizer;

src/video_core/renderer_opengl/gl_blit_screen.cpp

@@ -0,0 +1,96 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/settings.h"
+#include "video_core/renderer_opengl/gl_blit_screen.h"
+#include "video_core/renderer_opengl/gl_state_tracker.h"
+#include "video_core/renderer_opengl/present/filters.h"
+#include "video_core/renderer_opengl/present/layer.h"
+#include "video_core/renderer_opengl/present/window_adapt_pass.h"
+
+namespace OpenGL {
+
+BlitScreen::BlitScreen(RasterizerOpenGL& rasterizer_,
+                       Tegra::MaxwellDeviceMemoryManager& device_memory_,
+                       StateTracker& state_tracker_, ProgramManager& program_manager_,
+                       Device& device_)
+    : rasterizer(rasterizer_), device_memory(device_memory_), state_tracker(state_tracker_),
+      program_manager(program_manager_), device(device_) {}
+
+BlitScreen::~BlitScreen() = default;
+
+void BlitScreen::DrawScreen(std::span<const Tegra::FramebufferConfig> framebuffers,
+                            const Layout::FramebufferLayout& layout) {
+    // TODO: Signal state tracker about these changes
+    state_tracker.NotifyScreenDrawVertexArray();
+    state_tracker.NotifyPolygonModes();
+    state_tracker.NotifyViewport0();
+    state_tracker.NotifyScissor0();
+    state_tracker.NotifyColorMask(0);
+    state_tracker.NotifyBlend0();
+    state_tracker.NotifyFramebuffer();
+    state_tracker.NotifyFrontFace();
+    state_tracker.NotifyCullTest();
+    state_tracker.NotifyDepthTest();
+    state_tracker.NotifyStencilTest();
+    state_tracker.NotifyPolygonOffset();
+    state_tracker.NotifyRasterizeEnable();
+    state_tracker.NotifyFramebufferSRGB();
+    state_tracker.NotifyLogicOp();
+    state_tracker.NotifyClipControl();
+    state_tracker.NotifyAlphaTest();
+    state_tracker.ClipControl(GL_LOWER_LEFT, GL_ZERO_TO_ONE);
+
+    glEnable(GL_CULL_FACE);
+    glDisable(GL_COLOR_LOGIC_OP);
+    glDisable(GL_DEPTH_TEST);
+    glDisable(GL_STENCIL_TEST);
+    glDisable(GL_POLYGON_OFFSET_FILL);
+    glDisable(GL_RASTERIZER_DISCARD);
+    glDisable(GL_ALPHA_TEST);
+    glDisablei(GL_BLEND, 0);
+    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+    glCullFace(GL_BACK);
+    glFrontFace(GL_CW);
+    glColorMaski(0, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    glDepthRangeIndexed(0, 0.0, 0.0);
+
+    while (layers.size() < framebuffers.size()) {
+        layers.emplace_back(rasterizer, device_memory);
+    }
+
+    CreateWindowAdapt();
+    window_adapt->DrawToFramebuffer(program_manager, layers, framebuffers, layout);
+
+    // TODO
+    // program_manager.RestoreGuestPipeline();
+}
+
+void BlitScreen::CreateWindowAdapt() {
+    if (window_adapt && Settings::values.scaling_filter.GetValue() == current_window_adapt) {
+        return;
+    }
+
+    current_window_adapt = Settings::values.scaling_filter.GetValue();
+    switch (current_window_adapt) {
+    case Settings::ScalingFilter::NearestNeighbor:
+        window_adapt = MakeNearestNeighbor(device);
+        break;
+    case Settings::ScalingFilter::Bicubic:
+        window_adapt = MakeBicubic(device);
+        break;
+    case Settings::ScalingFilter::Gaussian:
+        window_adapt = MakeGaussian(device);
+        break;
+    case Settings::ScalingFilter::ScaleForce:
+        window_adapt = MakeScaleForce(device);
+        break;
+    case Settings::ScalingFilter::Fsr:
+    case Settings::ScalingFilter::Bilinear:
+    default:
+        window_adapt = MakeBilinear(device);
+        break;
+    }
+}
+
+} // namespace OpenGL

src/video_core/renderer_opengl/gl_blit_screen.h

@@ -0,0 +1,71 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <list>
+#include <memory>
+#include <span>
+
+#include "core/hle/service/nvnflinger/pixel_format.h"
+#include "video_core/host1x/gpu_device_memory_manager.h"
+#include "video_core/renderer_opengl/gl_resource_manager.h"
+
+namespace Layout {
+struct FramebufferLayout;
+}
+
+namespace Tegra {
+struct FramebufferConfig;
+}
+
+namespace Settings {
+enum class ScalingFilter : u32;
+}
+
+namespace OpenGL {
+
+class Device;
+class Layer;
+class ProgramManager;
+class RasterizerOpenGL;
+class StateTracker;
+class WindowAdaptPass;
+
+/// Structure used for storing information about the display target for the Switch screen
+struct FramebufferTextureInfo {
+    GLuint display_texture{};
+    u32 width;
+    u32 height;
+    u32 scaled_width;
+    u32 scaled_height;
+};
+
+class BlitScreen {
+public:
+    explicit BlitScreen(RasterizerOpenGL& rasterizer,
+                        Tegra::MaxwellDeviceMemoryManager& device_memory,
+                        StateTracker& state_tracker, ProgramManager& program_manager,
+                        Device& device);
+    ~BlitScreen();
+
+    /// Draws the emulated screens to the emulator window.
+    void DrawScreen(std::span<const Tegra::FramebufferConfig> framebuffers,
+                    const Layout::FramebufferLayout& layout);
+
+private:
+    void CreateWindowAdapt();
+
+    RasterizerOpenGL& rasterizer;
+    Tegra::MaxwellDeviceMemoryManager& device_memory;
+    StateTracker& state_tracker;
+    ProgramManager& program_manager;
+    Device& device;
+
+    Settings::ScalingFilter current_window_adapt{};
+    std::unique_ptr<WindowAdaptPass> window_adapt;
+
+    std::list<Layer> layers;
+};
+
+} // namespace OpenGL

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -71,10 +71,10 @@ std::optional<VideoCore::QueryType> MaxwellToVideoCoreQuery(VideoCommon::QueryTy
 
 RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,
                                    Tegra::MaxwellDeviceMemoryManager& device_memory_,
-                                   const Device& device_, ScreenInfo& screen_info_,
-                                   ProgramManager& program_manager_, StateTracker& state_tracker_)
-    : gpu(gpu_), device_memory(device_memory_), device(device_), screen_info(screen_info_),
-      program_manager(program_manager_), state_tracker(state_tracker_),
+                                   const Device& device_, ProgramManager& program_manager_,
+                                   StateTracker& state_tracker_)
+    : gpu(gpu_), device_memory(device_memory_), device(device_), program_manager(program_manager_),
+      state_tracker(state_tracker_),
       texture_cache_runtime(device, program_manager, state_tracker, staging_buffer_pool),
       texture_cache(texture_cache_runtime, device_memory_),
       buffer_cache_runtime(device, staging_buffer_pool),
@@ -739,27 +739,29 @@ void RasterizerOpenGL::AccelerateInlineToMemory(GPUVAddr address, size_t copy_si
     query_cache.InvalidateRegion(*cpu_addr, copy_size);
 }
 
-bool RasterizerOpenGL::AccelerateDisplay(const Tegra::FramebufferConfig& config,
-                                         DAddr framebuffer_addr, u32 pixel_stride) {
+std::optional<FramebufferTextureInfo> RasterizerOpenGL::AccelerateDisplay(
+    const Tegra::FramebufferConfig& config, DAddr framebuffer_addr, u32 pixel_stride) {
     if (framebuffer_addr == 0) {
-        return false;
+        return {};
     }
     MICROPROFILE_SCOPE(OpenGL_CacheManagement);
 
     std::scoped_lock lock{texture_cache.mutex};
-    ImageView* const image_view{
-        texture_cache.TryFindFramebufferImageView(config, framebuffer_addr)};
+    const auto [image_view, scaled] =
+        texture_cache.TryFindFramebufferImageView(config, framebuffer_addr);
     if (!image_view) {
-        return false;
+        return {};
     }
-    // Verify that the cached surface is the same size and format as the requested framebuffer
-    // ASSERT_MSG(image_view->size.width == config.width, "Framebuffer width is different");
-    // ASSERT_MSG(image_view->size.height == config.height, "Framebuffer height is different");
 
-    screen_info.texture.width = image_view->size.width;
-    screen_info.texture.height = image_view->size.height;
-    screen_info.display_texture = image_view->Handle(Shader::TextureType::Color2D);
-    return true;
+    const auto& resolution = Settings::values.resolution_info;
+
+    FramebufferTextureInfo info{};
+    info.display_texture = image_view->Handle(Shader::TextureType::Color2D);
+    info.width = image_view->size.width;
+    info.height = image_view->size.height;
+    info.scaled_width = scaled ? resolution.ScaleUp(info.width) : info.width;
+    info.scaled_height = scaled ? resolution.ScaleUp(info.height) : info.height;
+    return info;
 }
 
 void RasterizerOpenGL::SyncState() {

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -16,6 +16,7 @@
 #include "video_core/engines/maxwell_dma.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_opengl/blit_image.h"
+#include "video_core/renderer_opengl/gl_blit_screen.h"
 #include "video_core/renderer_opengl/gl_buffer_cache.h"
 #include "video_core/renderer_opengl/gl_device.h"
 #include "video_core/renderer_opengl/gl_fence_manager.h"
@@ -37,7 +38,7 @@ class MemoryManager;
 
 namespace OpenGL {
 
-struct ScreenInfo;
+struct FramebufferTextureInfo;
 struct ShaderEntries;
 
 struct BindlessSSBO {
@@ -76,8 +77,8 @@ class RasterizerOpenGL : public VideoCore::RasterizerInterface,
 public:
     explicit RasterizerOpenGL(Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,
                               Tegra::MaxwellDeviceMemoryManager& device_memory_,
-                              const Device& device_, ScreenInfo& screen_info_,
-                              ProgramManager& program_manager_, StateTracker& state_tracker_);
+                              const Device& device_, ProgramManager& program_manager_,
+                              StateTracker& state_tracker_);
     ~RasterizerOpenGL() override;
 
     void Draw(bool is_indexed, u32 instance_count) override;
@@ -122,8 +123,6 @@ public:
     Tegra::Engines::AccelerateDMAInterface& AccessAccelerateDMA() override;
     void AccelerateInlineToMemory(GPUVAddr address, size_t copy_size,
                                   std::span<const u8> memory) override;
-    bool AccelerateDisplay(const Tegra::FramebufferConfig& config, DAddr framebuffer_addr,
-                           u32 pixel_stride) override;
     void LoadDiskResources(u64 title_id, std::stop_token stop_loading,
                            const VideoCore::DiskResourceLoadCallback& callback) override;
 
@@ -144,6 +143,10 @@ public:
         return true;
     }
 
+    std::optional<FramebufferTextureInfo> AccelerateDisplay(const Tegra::FramebufferConfig& config,
+                                                            VAddr framebuffer_addr,
+                                                            u32 pixel_stride);
+
 private:
     static constexpr size_t MAX_TEXTURES = 192;
     static constexpr size_t MAX_IMAGES = 48;
@@ -237,7 +240,6 @@ private:
     Tegra::MaxwellDeviceMemoryManager& device_memory;
 
     const Device& device;
-    ScreenInfo& screen_info;
     ProgramManager& program_manager;
     StateTracker& state_tracker;
 

src/video_core/renderer_opengl/gl_texture_cache.cpp

@@ -1051,6 +1051,10 @@ void Image::Scale(bool up_scale) {
     state_tracker.NotifyScissor0();
 }
 
+bool Image::IsRescaled() const {
+    return True(flags & ImageFlagBits::Rescaled);
+}
+
 bool Image::ScaleUp(bool ignore) {
     const auto& resolution = runtime->resolution;
     if (!resolution.active) {

src/video_core/renderer_opengl/gl_texture_cache.h

@@ -217,6 +217,8 @@ public:
         return gl_type;
     }
 
+    bool IsRescaled() const;
+
     bool ScaleUp(bool ignore = false);
 
     bool ScaleDown(bool ignore = false);

src/video_core/renderer_opengl/present/filters.cpp

@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "video_core/host_shaders/opengl_present_frag.h"
+#include "video_core/host_shaders/opengl_present_scaleforce_frag.h"
+#include "video_core/host_shaders/present_bicubic_frag.h"
+#include "video_core/host_shaders/present_gaussian_frag.h"
+#include "video_core/renderer_opengl/present/filters.h"
+#include "video_core/renderer_opengl/present/util.h"
+
+namespace OpenGL {
+
+std::unique_ptr<WindowAdaptPass> MakeNearestNeighbor(const Device& device) {
+    return std::make_unique<WindowAdaptPass>(device, CreateNearestNeighborSampler(),
+                                             HostShaders::OPENGL_PRESENT_FRAG);
+}
+
+std::unique_ptr<WindowAdaptPass> MakeBilinear(const Device& device) {
+    return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
+                                             HostShaders::OPENGL_PRESENT_FRAG);
+}
+
+std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device) {
+    return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
+                                             HostShaders::PRESENT_BICUBIC_FRAG);
+}
+
+std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device) {
+    return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
+                                             HostShaders::PRESENT_GAUSSIAN_FRAG);
+}
+
+std::unique_ptr<WindowAdaptPass> MakeScaleForce(const Device& device) {
+    return std::make_unique<WindowAdaptPass>(
+        device, CreateBilinearSampler(),
+        fmt::format("#version 460\n{}", HostShaders::OPENGL_PRESENT_SCALEFORCE_FRAG));
+}
+
+} // namespace OpenGL

src/video_core/renderer_opengl/present/filters.h

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include "video_core/renderer_opengl/present/window_adapt_pass.h"
+
+namespace OpenGL {
+
+std::unique_ptr<WindowAdaptPass> MakeNearestNeighbor(const Device& device);
+std::unique_ptr<WindowAdaptPass> MakeBilinear(const Device& device);
+std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device);
+std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device);
+std::unique_ptr<WindowAdaptPass> MakeScaleForce(const Device& device);
+
+} // namespace OpenGL

src/video_core/renderer_opengl/present/fsr.cpp

@@ -0,0 +1,98 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/settings.h"
+#include "video_core/fsr.h"
+#include "video_core/host_shaders/ffx_a_h.h"
+#include "video_core/host_shaders/ffx_fsr1_h.h"
+#include "video_core/host_shaders/full_screen_triangle_vert.h"
+#include "video_core/host_shaders/opengl_fidelityfx_fsr_easu_frag.h"
+#include "video_core/host_shaders/opengl_fidelityfx_fsr_frag.h"
+#include "video_core/host_shaders/opengl_fidelityfx_fsr_rcas_frag.h"
+#include "video_core/renderer_opengl/gl_shader_manager.h"
+#include "video_core/renderer_opengl/gl_shader_util.h"
+#include "video_core/renderer_opengl/present/fsr.h"
+#include "video_core/renderer_opengl/present/util.h"
+
+namespace OpenGL {
+using namespace FSR;
+
+using FsrConstants = std::array<u32, 4 * 4>;
+
+FSR::FSR(u32 output_width_, u32 output_height_) : width(output_width_), height(output_height_) {
+    std::string fsr_source{HostShaders::OPENGL_FIDELITYFX_FSR_FRAG};
+    ReplaceInclude(fsr_source, "ffx_a.h", HostShaders::FFX_A_H);
+    ReplaceInclude(fsr_source, "ffx_fsr1.h", HostShaders::FFX_FSR1_H);
+
+    std::string fsr_easu_source{HostShaders::OPENGL_FIDELITYFX_FSR_EASU_FRAG};
+    std::string fsr_rcas_source{HostShaders::OPENGL_FIDELITYFX_FSR_RCAS_FRAG};
+    ReplaceInclude(fsr_easu_source, "opengl_fidelityfx_fsr.frag", fsr_source);
+    ReplaceInclude(fsr_rcas_source, "opengl_fidelityfx_fsr.frag", fsr_source);
+
+    vert = CreateProgram(HostShaders::FULL_SCREEN_TRIANGLE_VERT, GL_VERTEX_SHADER);
+    easu_frag = CreateProgram(fsr_easu_source, GL_FRAGMENT_SHADER);
+    rcas_frag = CreateProgram(fsr_rcas_source, GL_FRAGMENT_SHADER);
+
+    glProgramUniform2f(vert.handle, 0, 1.0f, -1.0f);
+    glProgramUniform2f(vert.handle, 1, 0.0f, 1.0f);
+
+    sampler = CreateBilinearSampler();
+    framebuffer.Create();
+
+    easu_tex.Create(GL_TEXTURE_2D);
+    glTextureStorage2D(easu_tex.handle, 1, GL_RGBA16F, width, height);
+
+    rcas_tex.Create(GL_TEXTURE_2D);
+    glTextureStorage2D(rcas_tex.handle, 1, GL_RGBA16F, width, height);
+}
+
+FSR::~FSR() = default;
+
+GLuint FSR::Draw(ProgramManager& program_manager, GLuint texture, u32 input_image_width,
+                 u32 input_image_height, const Common::Rectangle<f32>& crop_rect) {
+    const f32 input_width = static_cast<f32>(input_image_width);
+    const f32 input_height = static_cast<f32>(input_image_height);
+    const f32 output_width = static_cast<f32>(width);
+    const f32 output_height = static_cast<f32>(height);
+    const f32 viewport_width = (crop_rect.right - crop_rect.left) * input_width;
+    const f32 viewport_x = crop_rect.left * input_width;
+    const f32 viewport_height = (crop_rect.bottom - crop_rect.top) * input_height;
+    const f32 viewport_y = crop_rect.top * input_height;
+
+    FsrConstants easu_con{};
+    FsrConstants rcas_con{};
+
+    FsrEasuConOffset(easu_con.data() + 0, easu_con.data() + 4, easu_con.data() + 8,
+                     easu_con.data() + 12, viewport_width, viewport_height, input_width,
+                     input_height, output_width, output_height, viewport_x, viewport_y);
+
+    const float sharpening =
+        static_cast<float>(Settings::values.fsr_sharpening_slider.GetValue()) / 100.0f;
+
+    FsrRcasCon(rcas_con.data(), sharpening);
+
+    glProgramUniform4uiv(easu_frag.handle, 0, sizeof(easu_con), easu_con.data());
+    glProgramUniform4uiv(rcas_frag.handle, 0, sizeof(rcas_con), rcas_con.data());
+
+    glFrontFace(GL_CW);
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffer.handle);
+    glNamedFramebufferTexture(framebuffer.handle, GL_COLOR_ATTACHMENT0, easu_tex.handle, 0);
+    glViewportIndexedf(0, 0.0f, 0.0f, output_width, output_height);
+    program_manager.BindPresentPrograms(vert.handle, easu_frag.handle);
+    glBindTextureUnit(0, texture);
+    glBindSampler(0, sampler.handle);
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+
+    glNamedFramebufferTexture(framebuffer.handle, GL_COLOR_ATTACHMENT0, rcas_tex.handle, 0);
+    program_manager.BindPresentPrograms(vert.handle, rcas_frag.handle);
+    glBindTextureUnit(0, easu_tex.handle);
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+
+    return rcas_tex.handle;
+}
+
+bool FSR::NeedsRecreation(const Common::Rectangle<u32>& screen) {
+    return screen.GetWidth() != width || screen.GetHeight() != height;
+}
+
+} // namespace OpenGL

src/video_core/renderer_opengl/present/fsr.h

@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string_view>
+
+#include "common/common_types.h"
+#include "common/math_util.h"
+#include "video_core/fsr.h"
+#include "video_core/renderer_opengl/gl_resource_manager.h"
+
+namespace OpenGL {
+
+class ProgramManager;
+
+class FSR {
+public:
+    explicit FSR(u32 output_width, u32 output_height);
+    ~FSR();
+
+    GLuint Draw(ProgramManager& program_manager, GLuint texture, u32 input_image_width,
+                u32 input_image_height, const Common::Rectangle<f32>& crop_rect);
+
+    bool NeedsRecreation(const Common::Rectangle<u32>& screen);
+
+private:
+    const u32 width;
+    const u32 height;
+    OGLFramebuffer framebuffer;
+    OGLSampler sampler;
+    OGLProgram vert;
+    OGLProgram easu_frag;
+    OGLProgram rcas_frag;
+    OGLTexture easu_tex;
+    OGLTexture rcas_tex;
+};
+
+} // namespace OpenGL

src/video_core/renderer_opengl/present/fxaa.cpp

@@ -0,0 +1,41 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "video_core/host_shaders/fxaa_frag.h"
+#include "video_core/host_shaders/fxaa_vert.h"
+#include "video_core/renderer_opengl/gl_shader_manager.h"
+#include "video_core/renderer_opengl/gl_shader_util.h"
+#include "video_core/renderer_opengl/present/fxaa.h"
+#include "video_core/renderer_opengl/present/util.h"
+
+namespace OpenGL {
+
+FXAA::FXAA(u32 width, u32 height) {
+    vert_shader = CreateProgram(HostShaders::FXAA_VERT, GL_VERTEX_SHADER);
+    frag_shader = CreateProgram(HostShaders::FXAA_FRAG, GL_FRAGMENT_SHADER);
+
+    sampler = CreateBilinearSampler();
+
+    framebuffer.Create();
+
+    texture.Create(GL_TEXTURE_2D);
+    glTextureStorage2D(texture.handle, 1, GL_RGBA16F, width, height);
+    glNamedFramebufferTexture(framebuffer.handle, GL_COLOR_ATTACHMENT0, texture.handle, 0);
+}
+
+FXAA::~FXAA() = default;
+
+GLuint FXAA::Draw(ProgramManager& program_manager, GLuint input_texture) {
+    glFrontFace(GL_CCW);
+
+    program_manager.BindPresentPrograms(vert_shader.handle, frag_shader.handle);
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffer.handle);
+    glBindTextureUnit(0, input_texture);
+    glBindSampler(0, sampler.handle);
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+    glFrontFace(GL_CW);
+
+    return texture.handle;
+}
+
+} // namespace OpenGL

src/video_core/renderer_opengl/present/fxaa.h

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "video_core/renderer_opengl/gl_resource_manager.h"
+
+namespace OpenGL {
+
+class ProgramManager;
+
+class FXAA {
+public:
+    explicit FXAA(u32 width, u32 height);
+    ~FXAA();
+
+    GLuint Draw(ProgramManager& program_manager, GLuint input_texture);
+
+private:
+    OGLProgram vert_shader;
+    OGLProgram frag_shader;
+    OGLSampler sampler;
+    OGLFramebuffer framebuffer;
+    OGLTexture texture;
+};
+
+} // namespace OpenGL

src/video_core/renderer_opengl/present/layer.cpp

@@ -0,0 +1,215 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "video_core/framebuffer_config.h"
+#include "video_core/renderer_opengl/gl_blit_screen.h"
+#include "video_core/renderer_opengl/gl_rasterizer.h"
+#include "video_core/renderer_opengl/present/fsr.h"
+#include "video_core/renderer_opengl/present/fxaa.h"
+#include "video_core/renderer_opengl/present/layer.h"
+#include "video_core/renderer_opengl/present/present_uniforms.h"
+#include "video_core/renderer_opengl/present/smaa.h"
+#include "video_core/surface.h"
+#include "video_core/textures/decoders.h"
+
+namespace OpenGL {
+
+Layer::Layer(RasterizerOpenGL& rasterizer_, Tegra::MaxwellDeviceMemoryManager& device_memory_)
+    : rasterizer(rasterizer_), device_memory(device_memory_) {
+    // Allocate textures for the screen
+    framebuffer_texture.resource.Create(GL_TEXTURE_2D);
+
+    const GLuint texture = framebuffer_texture.resource.handle;
+    glTextureStorage2D(texture, 1, GL_RGBA8, 1, 1);
+
+    // Clear screen to black
+    const u8 framebuffer_data[4] = {0, 0, 0, 0};
+    glClearTexImage(framebuffer_texture.resource.handle, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                    framebuffer_data);
+}
+
+Layer::~Layer() = default;
+
+GLuint Layer::ConfigureDraw(std::array<GLfloat, 3 * 2>& out_matrix,
+                            std::array<ScreenRectVertex, 4>& out_vertices,
+                            ProgramManager& program_manager,
+                            const Tegra::FramebufferConfig& framebuffer,
+                            const Layout::FramebufferLayout& layout) {
+    FramebufferTextureInfo info = PrepareRenderTarget(framebuffer);
+    auto crop = Tegra::NormalizeCrop(framebuffer, info.width, info.height);
+    GLuint texture = info.display_texture;
+
+    auto anti_aliasing = Settings::values.anti_aliasing.GetValue();
+    if (anti_aliasing != Settings::AntiAliasing::None) {
+        glEnablei(GL_SCISSOR_TEST, 0);
+        auto viewport_width = Settings::values.resolution_info.ScaleUp(framebuffer_texture.width);
+        auto viewport_height = Settings::values.resolution_info.ScaleUp(framebuffer_texture.height);
+
+        glScissorIndexed(0, 0, 0, viewport_width, viewport_height);
+        glViewportIndexedf(0, 0.0f, 0.0f, static_cast<GLfloat>(viewport_width),
+                           static_cast<GLfloat>(viewport_height));
+
+        switch (anti_aliasing) {
+        case Settings::AntiAliasing::Fxaa:
+            CreateFXAA();
+            texture = fxaa->Draw(program_manager, info.display_texture);
+            break;
+        case Settings::AntiAliasing::Smaa:
+        default:
+            CreateSMAA();
+            texture = smaa->Draw(program_manager, info.display_texture);
+            break;
+        }
+    }
+
+    glDisablei(GL_SCISSOR_TEST, 0);
+
+    if (Settings::values.scaling_filter.GetValue() == Settings::ScalingFilter::Fsr) {
+        if (!fsr || fsr->NeedsRecreation(layout.screen)) {
+            fsr = std::make_unique<FSR>(layout.screen.GetWidth(), layout.screen.GetHeight());
+        }
+
+        texture = fsr->Draw(program_manager, texture, info.scaled_width, info.scaled_height, crop);
+        crop = {0, 0, 1, 1};
+    }
+
+    out_matrix =
+        MakeOrthographicMatrix(static_cast<float>(layout.width), static_cast<float>(layout.height));
+
+    // Map the coordinates to the screen.
+    const auto& screen = layout.screen;
+    const auto x = screen.left;
+    const auto y = screen.top;
+    const auto w = screen.GetWidth();
+    const auto h = screen.GetHeight();
+
+    out_vertices[0] = ScreenRectVertex(x, y, crop.left, crop.top);
+    out_vertices[1] = ScreenRectVertex(x + w, y, crop.right, crop.top);
+    out_vertices[2] = ScreenRectVertex(x, y + h, crop.left, crop.bottom);
+    out_vertices[3] = ScreenRectVertex(x + w, y + h, crop.right, crop.bottom);
+
+    return texture;
+}
+
+FramebufferTextureInfo Layer::PrepareRenderTarget(const Tegra::FramebufferConfig& framebuffer) {
+    // If framebuffer is provided, reload it from memory to a texture
+    if (framebuffer_texture.width != static_cast<GLsizei>(framebuffer.width) ||
+        framebuffer_texture.height != static_cast<GLsizei>(framebuffer.height) ||
+        framebuffer_texture.pixel_format != framebuffer.pixel_format ||
+        gl_framebuffer_data.empty()) {
+        // Reallocate texture if the framebuffer size has changed.
+        // This is expected to not happen very often and hence should not be a
+        // performance problem.
+        ConfigureFramebufferTexture(framebuffer);
+    }
+
+    // Load the framebuffer from memory if needed
+    return LoadFBToScreenInfo(framebuffer);
+}
+
+FramebufferTextureInfo Layer::LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuffer) {
+    const VAddr framebuffer_addr{framebuffer.address + framebuffer.offset};
+    const auto accelerated_info =
+        rasterizer.AccelerateDisplay(framebuffer, framebuffer_addr, framebuffer.stride);
+    if (accelerated_info) {
+        return *accelerated_info;
+    }
+
+    // Reset the screen info's display texture to its own permanent texture
+    FramebufferTextureInfo info{};
+    info.display_texture = framebuffer_texture.resource.handle;
+    info.width = framebuffer.width;
+    info.height = framebuffer.height;
+    info.scaled_width = framebuffer.width;
+    info.scaled_height = framebuffer.height;
+
+    // TODO(Rodrigo): Read this from HLE
+    constexpr u32 block_height_log2 = 4;
+    const auto pixel_format{
+        VideoCore::Surface::PixelFormatFromGPUPixelFormat(framebuffer.pixel_format)};
+    const u32 bytes_per_pixel{VideoCore::Surface::BytesPerBlock(pixel_format)};
+    const u64 size_in_bytes{Tegra::Texture::CalculateSize(
+        true, bytes_per_pixel, framebuffer.stride, framebuffer.height, 1, block_height_log2, 0)};
+    const u8* const host_ptr{device_memory.GetPointer<u8>(framebuffer_addr)};
+    const std::span<const u8> input_data(host_ptr, size_in_bytes);
+    Tegra::Texture::UnswizzleTexture(gl_framebuffer_data, input_data, bytes_per_pixel,
+                                     framebuffer.width, framebuffer.height, 1, block_height_log2,
+                                     0);
+
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, static_cast<GLint>(framebuffer.stride));
+
+    // Update existing texture
+    // TODO: Test what happens on hardware when you change the framebuffer dimensions so that
+    //       they differ from the LCD resolution.
+    // TODO: Applications could theoretically crash yuzu here by specifying too large
+    //       framebuffer sizes. We should make sure that this cannot happen.
+    glTextureSubImage2D(framebuffer_texture.resource.handle, 0, 0, 0, framebuffer.width,
+                        framebuffer.height, framebuffer_texture.gl_format,
+                        framebuffer_texture.gl_type, gl_framebuffer_data.data());
+
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+
+    return info;
+}
+
+void Layer::ConfigureFramebufferTexture(const Tegra::FramebufferConfig& framebuffer) {
+    framebuffer_texture.width = framebuffer.width;
+    framebuffer_texture.height = framebuffer.height;
+    framebuffer_texture.pixel_format = framebuffer.pixel_format;
+
+    const auto pixel_format{
+        VideoCore::Surface::PixelFormatFromGPUPixelFormat(framebuffer.pixel_format)};
+    const u32 bytes_per_pixel{VideoCore::Surface::BytesPerBlock(pixel_format)};
+    gl_framebuffer_data.resize(framebuffer_texture.width * framebuffer_texture.height *
+                               bytes_per_pixel);
+
+    GLint internal_format;
+    switch (framebuffer.pixel_format) {
+    case Service::android::PixelFormat::Rgba8888:
+        internal_format = GL_RGBA8;
+        framebuffer_texture.gl_format = GL_RGBA;
+        framebuffer_texture.gl_type = GL_UNSIGNED_INT_8_8_8_8_REV;
+        break;
+    case Service::android::PixelFormat::Rgb565:
+        internal_format = GL_RGB565;
+        framebuffer_texture.gl_format = GL_RGB;
+        framebuffer_texture.gl_type = GL_UNSIGNED_SHORT_5_6_5;
+        break;
+    default:
+        internal_format = GL_RGBA8;
+        framebuffer_texture.gl_format = GL_RGBA;
+        framebuffer_texture.gl_type = GL_UNSIGNED_INT_8_8_8_8_REV;
+        // UNIMPLEMENTED_MSG("Unknown framebuffer pixel format: {}",
+        //                   static_cast<u32>(framebuffer.pixel_format));
+        break;
+    }
+
+    framebuffer_texture.resource.Release();
+    framebuffer_texture.resource.Create(GL_TEXTURE_2D);
+    glTextureStorage2D(framebuffer_texture.resource.handle, 1, internal_format,
+                       framebuffer_texture.width, framebuffer_texture.height);
+
+    fxaa.reset();
+    smaa.reset();
+}
+
+void Layer::CreateFXAA() {
+    smaa.reset();
+    if (!fxaa) {
+        fxaa = std::make_unique<FXAA>(
+            Settings::values.resolution_info.ScaleUp(framebuffer_texture.width),
+            Settings::values.resolution_info.ScaleUp(framebuffer_texture.height));
+    }
+}
+
+void Layer::CreateSMAA() {
+    fxaa.reset();
+    if (!smaa) {
+        smaa = std::make_unique<SMAA>(
+            Settings::values.resolution_info.ScaleUp(framebuffer_texture.width),
+            Settings::values.resolution_info.ScaleUp(framebuffer_texture.height));
+    }
+}
+
+} // namespace OpenGL

src/video_core/renderer_opengl/present/layer.h

@@ -0,0 +1,80 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "video_core/host1x/gpu_device_memory_manager.h"
+#include "video_core/renderer_opengl/gl_resource_manager.h"
+
+namespace Layout {
+struct FramebufferLayout;
+}
+
+namespace Service::android {
+enum class PixelFormat : u32;
+};
+
+namespace Tegra {
+struct FramebufferConfig;
+}
+
+namespace OpenGL {
+
+struct FramebufferTextureInfo;
+class FSR;
+class FXAA;
+class ProgramManager;
+class RasterizerOpenGL;
+class SMAA;
+
+/// Structure used for storing information about the textures for the Switch screen
+struct TextureInfo {
+    OGLTexture resource;
+    GLsizei width;
+    GLsizei height;
+    GLenum gl_format;
+    GLenum gl_type;
+    Service::android::PixelFormat pixel_format;
+};
+
+struct ScreenRectVertex;
+
+class Layer {
+public:
+    explicit Layer(RasterizerOpenGL& rasterizer, Tegra::MaxwellDeviceMemoryManager& device_memory);
+    ~Layer();
+
+    GLuint ConfigureDraw(std::array<GLfloat, 3 * 2>& out_matrix,
+                         std::array<ScreenRectVertex, 4>& out_vertices,
+                         ProgramManager& program_manager,
+                         const Tegra::FramebufferConfig& framebuffer,
+                         const Layout::FramebufferLayout& layout);
+
+private:
+    /// Loads framebuffer from emulated memory into the active OpenGL texture.
+    FramebufferTextureInfo LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuffer);
+    FramebufferTextureInfo PrepareRenderTarget(const Tegra::FramebufferConfig& framebuffer);
+    void ConfigureFramebufferTexture(const Tegra::FramebufferConfig& framebuffer);
+
+    void CreateFXAA();
+    void CreateSMAA();
+
+private:
+    RasterizerOpenGL& rasterizer;
+    Tegra::MaxwellDeviceMemoryManager& device_memory;
+
+    /// OpenGL framebuffer data
+    std::vector<u8> gl_framebuffer_data;
+
+    /// Display information for Switch screen
+    TextureInfo framebuffer_texture;
+
+    std::unique_ptr<FSR> fsr;
+    std::unique_ptr<FXAA> fxaa;
+    std::unique_ptr<SMAA> smaa;
+};
+
+} // namespace OpenGL

src/video_core/renderer_opengl/present/present_uniforms.h

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "video_core/renderer_opengl/gl_resource_manager.h"
+
+namespace OpenGL {
+
+constexpr GLint PositionLocation = 0;
+constexpr GLint TexCoordLocation = 1;
+constexpr GLint ModelViewMatrixLocation = 0;
+
+struct ScreenRectVertex {
+    constexpr ScreenRectVertex() = default;
+
+    constexpr ScreenRectVertex(u32 x, u32 y, GLfloat u, GLfloat v)
+        : position{{static_cast<GLfloat>(x), static_cast<GLfloat>(y)}}, tex_coord{{u, v}} {}
+
+    std::array<GLfloat, 2> position{};
+    std::array<GLfloat, 2> tex_coord{};
+};
+
+/**
+ * Defines a 1:1 pixel orthographic projection matrix with (0,0) on the top-left
+ * corner and (width, height) on the lower-bottom.
+ *
+ * The projection part of the matrix is trivial, hence these operations are represented
+ * by a 3x2 matrix.
+ */
+static inline std::array<GLfloat, 3 * 2> MakeOrthographicMatrix(float width, float height) {
+    std::array<GLfloat, 3 * 2> matrix; // Laid out in column-major order
+
+    // clang-format off
+    matrix[0] = 2.f / width; matrix[2] =  0.f;          matrix[4] = -1.f;
+    matrix[1] = 0.f;         matrix[3] = -2.f / height; matrix[5] =  1.f;
+    // Last matrix row is implicitly assumed to be [0, 0, 1].
+    // clang-format on
+
+    return matrix;
+}
+
+} // namespace OpenGL

src/video_core/renderer_opengl/present/smaa.cpp

@@ -0,0 +1,102 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "video_core/host_shaders/opengl_smaa_glsl.h"
+#include "video_core/host_shaders/smaa_blending_weight_calculation_frag.h"
+#include "video_core/host_shaders/smaa_blending_weight_calculation_vert.h"
+#include "video_core/host_shaders/smaa_edge_detection_frag.h"
+#include "video_core/host_shaders/smaa_edge_detection_vert.h"
+#include "video_core/host_shaders/smaa_neighborhood_blending_frag.h"
+#include "video_core/host_shaders/smaa_neighborhood_blending_vert.h"
+#include "video_core/renderer_opengl/gl_shader_manager.h"
+#include "video_core/renderer_opengl/gl_shader_util.h"
+#include "video_core/renderer_opengl/present/smaa.h"
+#include "video_core/renderer_opengl/present/util.h"
+#include "video_core/smaa_area_tex.h"
+#include "video_core/smaa_search_tex.h"
+
+namespace OpenGL {
+
+SMAA::SMAA(u32 width, u32 height) {
+    const auto SmaaShader = [&](std::string_view specialized_source, GLenum stage) {
+        std::string shader_source{specialized_source};
+        ReplaceInclude(shader_source, "opengl_smaa.glsl", HostShaders::OPENGL_SMAA_GLSL);
+        return CreateProgram(shader_source, stage);
+    };
+
+    edge_detection_vert = SmaaShader(HostShaders::SMAA_EDGE_DETECTION_VERT, GL_VERTEX_SHADER);
+    edge_detection_frag = SmaaShader(HostShaders::SMAA_EDGE_DETECTION_FRAG, GL_FRAGMENT_SHADER);
+    blending_weight_calculation_vert =
+        SmaaShader(HostShaders::SMAA_BLENDING_WEIGHT_CALCULATION_VERT, GL_VERTEX_SHADER);
+    blending_weight_calculation_frag =
+        SmaaShader(HostShaders::SMAA_BLENDING_WEIGHT_CALCULATION_FRAG, GL_FRAGMENT_SHADER);
+    neighborhood_blending_vert =
+        SmaaShader(HostShaders::SMAA_NEIGHBORHOOD_BLENDING_VERT, GL_VERTEX_SHADER);
+    neighborhood_blending_frag =
+        SmaaShader(HostShaders::SMAA_NEIGHBORHOOD_BLENDING_FRAG, GL_FRAGMENT_SHADER);
+
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+
+    area_tex.Create(GL_TEXTURE_2D);
+    glTextureStorage2D(area_tex.handle, 1, GL_RG8, AREATEX_WIDTH, AREATEX_HEIGHT);
+    glTextureSubImage2D(area_tex.handle, 0, 0, 0, AREATEX_WIDTH, AREATEX_HEIGHT, GL_RG,
+                        GL_UNSIGNED_BYTE, areaTexBytes);
+    search_tex.Create(GL_TEXTURE_2D);
+    glTextureStorage2D(search_tex.handle, 1, GL_R8, SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT);
+    glTextureSubImage2D(search_tex.handle, 0, 0, 0, SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT, GL_RED,
+                        GL_UNSIGNED_BYTE, searchTexBytes);
+
+    edges_tex.Create(GL_TEXTURE_2D);
+    glTextureStorage2D(edges_tex.handle, 1, GL_RG16F, width, height);
+
+    blend_tex.Create(GL_TEXTURE_2D);
+    glTextureStorage2D(blend_tex.handle, 1, GL_RGBA16F, width, height);
+
+    sampler = CreateBilinearSampler();
+
+    framebuffer.Create();
+
+    texture.Create(GL_TEXTURE_2D);
+    glTextureStorage2D(texture.handle, 1, GL_RGBA16F, width, height);
+    glNamedFramebufferTexture(framebuffer.handle, GL_COLOR_ATTACHMENT0, texture.handle, 0);
+}
+
+SMAA::~SMAA() = default;
+
+GLuint SMAA::Draw(ProgramManager& program_manager, GLuint input_texture) {
+    glClearColor(0, 0, 0, 0);
+    glFrontFace(GL_CCW);
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffer.handle);
+    glBindSampler(0, sampler.handle);
+    glBindSampler(1, sampler.handle);
+    glBindSampler(2, sampler.handle);
+
+    glBindTextureUnit(0, input_texture);
+    glNamedFramebufferTexture(framebuffer.handle, GL_COLOR_ATTACHMENT0, edges_tex.handle, 0);
+    glClear(GL_COLOR_BUFFER_BIT);
+    program_manager.BindPresentPrograms(edge_detection_vert.handle, edge_detection_frag.handle);
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+
+    glBindTextureUnit(0, edges_tex.handle);
+    glBindTextureUnit(1, area_tex.handle);
+    glBindTextureUnit(2, search_tex.handle);
+    glNamedFramebufferTexture(framebuffer.handle, GL_COLOR_ATTACHMENT0, blend_tex.handle, 0);
+    glClear(GL_COLOR_BUFFER_BIT);
+    program_manager.BindPresentPrograms(blending_weight_calculation_vert.handle,
+                                        blending_weight_calculation_frag.handle);
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+
+    glBindTextureUnit(0, input_texture);
+    glBindTextureUnit(1, blend_tex.handle);
+    glNamedFramebufferTexture(framebuffer.handle, GL_COLOR_ATTACHMENT0, texture.handle, 0);
+    program_manager.BindPresentPrograms(neighborhood_blending_vert.handle,
+                                        neighborhood_blending_frag.handle);
+    glClear(GL_COLOR_BUFFER_BIT);
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+    glFrontFace(GL_CW);
+
+    return texture.handle;
+}
+
+} // namespace OpenGL

src/video_core/renderer_opengl/present/smaa.h

@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "video_core/renderer_opengl/gl_resource_manager.h"
+
+namespace OpenGL {
+
+class ProgramManager;
+
+class SMAA {
+public:
+    explicit SMAA(u32 width, u32 height);
+    ~SMAA();
+
+    GLuint Draw(ProgramManager& program_manager, GLuint input_texture);
+
+private:
+    OGLProgram edge_detection_vert;
+    OGLProgram blending_weight_calculation_vert;
+    OGLProgram neighborhood_blending_vert;
+    OGLProgram edge_detection_frag;
+    OGLProgram blending_weight_calculation_frag;
+    OGLProgram neighborhood_blending_frag;
+    OGLTexture area_tex;
+    OGLTexture search_tex;
+    OGLTexture edges_tex;
+    OGLTexture blend_tex;
+    OGLSampler sampler;
+    OGLFramebuffer framebuffer;
+    OGLTexture texture;
+};
+
+} // namespace OpenGL

src/video_core/renderer_opengl/present/util.h

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string>
+
+#include "common/assert.h"
+#include "video_core/renderer_opengl/gl_resource_manager.h"
+
+namespace OpenGL {
+
+static inline void ReplaceInclude(std::string& shader_source, std::string_view include_name,
+                                  std::string_view include_content) {
+    const std::string include_string = fmt::format("#include \"{}\"", include_name);
+    const std::size_t pos = shader_source.find(include_string);
+    ASSERT(pos != std::string::npos);
+    shader_source.replace(pos, include_string.size(), include_content);
+};
+
+static inline OGLSampler CreateBilinearSampler() {
+    OGLSampler sampler;
+    sampler.Create();
+    glSamplerParameteri(sampler.handle, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glSamplerParameteri(sampler.handle, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glSamplerParameteri(sampler.handle, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glSamplerParameteri(sampler.handle, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glSamplerParameteri(sampler.handle, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+    return sampler;
+}
+
+static inline OGLSampler CreateNearestNeighborSampler() {
+    OGLSampler sampler;
+    sampler.Create();
+    glSamplerParameteri(sampler.handle, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glSamplerParameteri(sampler.handle, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glSamplerParameteri(sampler.handle, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glSamplerParameteri(sampler.handle, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glSamplerParameteri(sampler.handle, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+    return sampler;
+}
+
+} // namespace OpenGL

src/video_core/renderer_opengl/present/window_adapt_pass.cpp

@@ -0,0 +1,103 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/settings.h"
+#include "video_core/framebuffer_config.h"
+#include "video_core/host_shaders/opengl_present_vert.h"
+#include "video_core/renderer_opengl/gl_device.h"
+#include "video_core/renderer_opengl/gl_shader_manager.h"
+#include "video_core/renderer_opengl/gl_shader_util.h"
+#include "video_core/renderer_opengl/present/layer.h"
+#include "video_core/renderer_opengl/present/present_uniforms.h"
+#include "video_core/renderer_opengl/present/window_adapt_pass.h"
+
+namespace OpenGL {
+
+WindowAdaptPass::WindowAdaptPass(const Device& device_, OGLSampler&& sampler_,
+                                 std::string_view frag_source)
+    : device(device_), sampler(std::move(sampler_)) {
+    vert = CreateProgram(HostShaders::OPENGL_PRESENT_VERT, GL_VERTEX_SHADER);
+    frag = CreateProgram(frag_source, GL_FRAGMENT_SHADER);
+
+    // Generate VBO handle for drawing
+    vertex_buffer.Create();
+
+    // Attach vertex data to VAO
+    glNamedBufferData(vertex_buffer.handle, sizeof(ScreenRectVertex) * 4, nullptr, GL_STREAM_DRAW);
+
+    // Query vertex buffer address when the driver supports unified vertex attributes
+    if (device.HasVertexBufferUnifiedMemory()) {
+        glMakeNamedBufferResidentNV(vertex_buffer.handle, GL_READ_ONLY);
+        glGetNamedBufferParameterui64vNV(vertex_buffer.handle, GL_BUFFER_GPU_ADDRESS_NV,
+                                         &vertex_buffer_address);
+    }
+}
+
+WindowAdaptPass::~WindowAdaptPass() = default;
+
+void WindowAdaptPass::DrawToFramebuffer(ProgramManager& program_manager, std::list<Layer>& layers,
+                                        std::span<const Tegra::FramebufferConfig> framebuffers,
+                                        const Layout::FramebufferLayout& layout) {
+    GLint old_read_fb;
+    GLint old_draw_fb;
+    glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &old_read_fb);
+    glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &old_draw_fb);
+
+    const size_t layer_count = framebuffers.size();
+    std::vector<GLuint> textures(layer_count);
+    std::vector<std::array<GLfloat, 3 * 2>> matrices(layer_count);
+    std::vector<std::array<ScreenRectVertex, 4>> vertices(layer_count);
+
+    auto layer_it = layers.begin();
+    for (size_t i = 0; i < layer_count; i++) {
+        textures[i] = layer_it->ConfigureDraw(matrices[i], vertices[i], program_manager,
+                                              framebuffers[i], layout);
+        layer_it++;
+    }
+
+    glBindFramebuffer(GL_READ_FRAMEBUFFER, old_read_fb);
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, old_draw_fb);
+
+    program_manager.BindPresentPrograms(vert.handle, frag.handle);
+
+    glDisable(GL_FRAMEBUFFER_SRGB);
+    glViewportIndexedf(0, 0.0f, 0.0f, static_cast<GLfloat>(layout.width),
+                       static_cast<GLfloat>(layout.height));
+
+    glEnableVertexAttribArray(PositionLocation);
+    glEnableVertexAttribArray(TexCoordLocation);
+    glVertexAttribDivisor(PositionLocation, 0);
+    glVertexAttribDivisor(TexCoordLocation, 0);
+    glVertexAttribFormat(PositionLocation, 2, GL_FLOAT, GL_FALSE,
+                         offsetof(ScreenRectVertex, position));
+    glVertexAttribFormat(TexCoordLocation, 2, GL_FLOAT, GL_FALSE,
+                         offsetof(ScreenRectVertex, tex_coord));
+    glVertexAttribBinding(PositionLocation, 0);
+    glVertexAttribBinding(TexCoordLocation, 0);
+    if (device.HasVertexBufferUnifiedMemory()) {
+        glBindVertexBuffer(0, 0, 0, sizeof(ScreenRectVertex));
+        glBufferAddressRangeNV(GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV, 0, vertex_buffer_address,
+                               sizeof(decltype(vertices)::value_type));
+    } else {
+        glBindVertexBuffer(0, vertex_buffer.handle, 0, sizeof(ScreenRectVertex));
+    }
+
+    glBindSampler(0, sampler.handle);
+
+    // Update background color before drawing
+    glClearColor(Settings::values.bg_red.GetValue() / 255.0f,
+                 Settings::values.bg_green.GetValue() / 255.0f,
+                 Settings::values.bg_blue.GetValue() / 255.0f, 1.0f);
+
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    for (size_t i = 0; i < layer_count; i++) {
+        glBindTextureUnit(0, textures[i]);
+        glProgramUniformMatrix3x2fv(vert.handle, ModelViewMatrixLocation, 1, GL_FALSE,
+                                    matrices[i].data());
+        glNamedBufferSubData(vertex_buffer.handle, 0, sizeof(vertices[i]), std::data(vertices[i]));
+        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+    }
+}
+
+} // namespace OpenGL

src/video_core/renderer_opengl/present/window_adapt_pass.h

@@ -0,0 +1,47 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <list>
+#include <span>
+
+#include "common/math_util.h"
+#include "video_core/renderer_opengl/gl_resource_manager.h"
+
+namespace Layout {
+struct FramebufferLayout;
+}
+
+namespace Tegra {
+struct FramebufferConfig;
+}
+
+namespace OpenGL {
+
+class Device;
+class Layer;
+class ProgramManager;
+
+class WindowAdaptPass final {
+public:
+    explicit WindowAdaptPass(const Device& device, OGLSampler&& sampler,
+                             std::string_view frag_source);
+    ~WindowAdaptPass();
+
+    void DrawToFramebuffer(ProgramManager& program_manager, std::list<Layer>& layers,
+                           std::span<const Tegra::FramebufferConfig> framebuffers,
+                           const Layout::FramebufferLayout& layout);
+
+private:
+    const Device& device;
+    OGLSampler sampler;
+    OGLProgram vert;
+    OGLProgram frag;
+    OGLBuffer vertex_buffer;
+
+    // GPU address of the vertex buffer
+    GLuint64EXT vertex_buffer_address = 0;
+};
+
+} // namespace OpenGL

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -16,68 +16,15 @@
 #include "core/core_timing.h"
 #include "core/frontend/emu_window.h"
 #include "core/telemetry_session.h"
-#include "video_core/host_shaders/ffx_a_h.h"
-#include "video_core/host_shaders/ffx_fsr1_h.h"
-#include "video_core/host_shaders/full_screen_triangle_vert.h"
-#include "video_core/host_shaders/fxaa_frag.h"
-#include "video_core/host_shaders/fxaa_vert.h"
-#include "video_core/host_shaders/opengl_fidelityfx_fsr_easu_frag.h"
-#include "video_core/host_shaders/opengl_fidelityfx_fsr_frag.h"
-#include "video_core/host_shaders/opengl_fidelityfx_fsr_rcas_frag.h"
-#include "video_core/host_shaders/opengl_present_frag.h"
-#include "video_core/host_shaders/opengl_present_scaleforce_frag.h"
-#include "video_core/host_shaders/opengl_present_vert.h"
-#include "video_core/host_shaders/opengl_smaa_glsl.h"
-#include "video_core/host_shaders/present_bicubic_frag.h"
-#include "video_core/host_shaders/present_gaussian_frag.h"
-#include "video_core/host_shaders/smaa_blending_weight_calculation_frag.h"
-#include "video_core/host_shaders/smaa_blending_weight_calculation_vert.h"
-#include "video_core/host_shaders/smaa_edge_detection_frag.h"
-#include "video_core/host_shaders/smaa_edge_detection_vert.h"
-#include "video_core/host_shaders/smaa_neighborhood_blending_frag.h"
-#include "video_core/host_shaders/smaa_neighborhood_blending_vert.h"
-#include "video_core/renderer_opengl/gl_fsr.h"
+#include "video_core/renderer_opengl/gl_blit_screen.h"
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/gl_shader_manager.h"
 #include "video_core/renderer_opengl/gl_shader_util.h"
 #include "video_core/renderer_opengl/renderer_opengl.h"
-#include "video_core/smaa_area_tex.h"
-#include "video_core/smaa_search_tex.h"
 #include "video_core/textures/decoders.h"
 
 namespace OpenGL {
 namespace {
-constexpr GLint PositionLocation = 0;
-constexpr GLint TexCoordLocation = 1;
-constexpr GLint ModelViewMatrixLocation = 0;
-
-struct ScreenRectVertex {
-    constexpr ScreenRectVertex(u32 x, u32 y, GLfloat u, GLfloat v)
-        : position{{static_cast<GLfloat>(x), static_cast<GLfloat>(y)}}, tex_coord{{u, v}} {}
-
-    std::array<GLfloat, 2> position;
-    std::array<GLfloat, 2> tex_coord;
-};
-
-/**
- * Defines a 1:1 pixel ortographic projection matrix with (0,0) on the top-left
- * corner and (width, height) on the lower-bottom.
- *
- * The projection part of the matrix is trivial, hence these operations are represented
- * by a 3x2 matrix.
- */
-std::array<GLfloat, 3 * 2> MakeOrthographicMatrix(float width, float height) {
-    std::array<GLfloat, 3 * 2> matrix; // Laid out in column-major order
-
-    // clang-format off
-    matrix[0] = 2.f / width; matrix[2] =  0.f;          matrix[4] = -1.f;
-    matrix[1] = 0.f;         matrix[3] = -2.f / height; matrix[5] =  1.f;
-    // Last matrix row is implicitly assumed to be [0, 0, 1].
-    // clang-format on
-
-    return matrix;
-}
-
 const char* GetSource(GLenum source) {
     switch (source) {
     case GL_DEBUG_SOURCE_API:
@@ -148,15 +95,13 @@ RendererOpenGL::RendererOpenGL(Core::TelemetrySession& telemetry_session_,
     : RendererBase{emu_window_, std::move(context_)}, telemetry_session{telemetry_session_},
       emu_window{emu_window_}, device_memory{device_memory_}, gpu{gpu_}, device{emu_window_},
       state_tracker{}, program_manager{device},
-      rasterizer(emu_window, gpu, device_memory, device, screen_info, program_manager,
-                 state_tracker) {
+      rasterizer(emu_window, gpu, device_memory, device, program_manager, state_tracker) {
     if (Settings::values.renderer_debug && GLAD_GL_KHR_debug) {
         glEnable(GL_DEBUG_OUTPUT);
         glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
         glDebugMessageCallback(DebugHandler, nullptr);
     }
     AddTelemetryFields();
-    InitOpenGLObjects();
 
     // Initialize default attributes to match hardware's disabled attributes
     GLint max_attribs{};
@@ -168,27 +113,27 @@ RendererOpenGL::RendererOpenGL(Core::TelemetrySession& telemetry_session_,
     if (!GLAD_GL_ARB_seamless_cubemap_per_texture && !GLAD_GL_AMD_seamless_cubemap_per_texture) {
         glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
     }
-    // Enable unified vertex attributes and query vertex buffer address when the driver supports it
+
+    // Enable unified vertex attributes when the driver supports it
     if (device.HasVertexBufferUnifiedMemory()) {
         glEnableClientState(GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV);
         glEnableClientState(GL_ELEMENT_ARRAY_UNIFIED_NV);
-        glMakeNamedBufferResidentNV(vertex_buffer.handle, GL_READ_ONLY);
-        glGetNamedBufferParameterui64vNV(vertex_buffer.handle, GL_BUFFER_GPU_ADDRESS_NV,
-                                         &vertex_buffer_address);
     }
+    blit_screen = std::make_unique<BlitScreen>(rasterizer, device_memory, state_tracker,
+                                               program_manager, device);
 }
 
 RendererOpenGL::~RendererOpenGL() = default;
 
-void RendererOpenGL::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
-    if (!framebuffer) {
+void RendererOpenGL::Composite(std::span<const Tegra::FramebufferConfig> framebuffers) {
+    if (framebuffers.empty()) {
         return;
     }
-    PrepareRendertarget(framebuffer);
-    RenderScreenshot();
+
+    RenderScreenshot(framebuffers);
 
     state_tracker.BindFramebuffer(0);
-    DrawScreen(emu_window.GetFramebufferLayout());
+    blit_screen->DrawScreen(framebuffers, emu_window.GetFramebufferLayout());
 
     ++m_current_frame;
 
@@ -199,172 +144,6 @@ void RendererOpenGL::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
     render_window.OnFrameDisplayed();
 }
 
-void RendererOpenGL::PrepareRendertarget(const Tegra::FramebufferConfig* framebuffer) {
-    if (!framebuffer) {
-        return;
-    }
-    // If framebuffer is provided, reload it from memory to a texture
-    if (screen_info.texture.width != static_cast<GLsizei>(framebuffer->width) ||
-        screen_info.texture.height != static_cast<GLsizei>(framebuffer->height) ||
-        screen_info.texture.pixel_format != framebuffer->pixel_format ||
-        gl_framebuffer_data.empty()) {
-        // Reallocate texture if the framebuffer size has changed.
-        // This is expected to not happen very often and hence should not be a
-        // performance problem.
-        ConfigureFramebufferTexture(screen_info.texture, *framebuffer);
-    }
-
-    // Load the framebuffer from memory, draw it to the screen, and swap buffers
-    LoadFBToScreenInfo(*framebuffer);
-}
-
-void RendererOpenGL::LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuffer) {
-    // Framebuffer orientation handling
-    framebuffer_transform_flags = framebuffer.transform_flags;
-    framebuffer_crop_rect = framebuffer.crop_rect;
-    framebuffer_width = framebuffer.width;
-    framebuffer_height = framebuffer.height;
-
-    const VAddr framebuffer_addr{framebuffer.address + framebuffer.offset};
-    screen_info.was_accelerated =
-        rasterizer.AccelerateDisplay(framebuffer, framebuffer_addr, framebuffer.stride);
-    if (screen_info.was_accelerated) {
-        return;
-    }
-
-    // Reset the screen info's display texture to its own permanent texture
-    screen_info.display_texture = screen_info.texture.resource.handle;
-
-    // TODO(Rodrigo): Read this from HLE
-    constexpr u32 block_height_log2 = 4;
-    const auto pixel_format{
-        VideoCore::Surface::PixelFormatFromGPUPixelFormat(framebuffer.pixel_format)};
-    const u32 bytes_per_pixel{VideoCore::Surface::BytesPerBlock(pixel_format)};
-    const u64 size_in_bytes{Tegra::Texture::CalculateSize(
-        true, bytes_per_pixel, framebuffer.stride, framebuffer.height, 1, block_height_log2, 0)};
-    const u8* const host_ptr{device_memory.GetPointer<u8>(framebuffer_addr)};
-    const std::span<const u8> input_data(host_ptr, size_in_bytes);
-    Tegra::Texture::UnswizzleTexture(gl_framebuffer_data, input_data, bytes_per_pixel,
-                                     framebuffer.width, framebuffer.height, 1, block_height_log2,
-                                     0);
-
-    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, static_cast<GLint>(framebuffer.stride));
-
-    // Update existing texture
-    // TODO: Test what happens on hardware when you change the framebuffer dimensions so that
-    //       they differ from the LCD resolution.
-    // TODO: Applications could theoretically crash yuzu here by specifying too large
-    //       framebuffer sizes. We should make sure that this cannot happen.
-    glTextureSubImage2D(screen_info.texture.resource.handle, 0, 0, 0, framebuffer.width,
-                        framebuffer.height, screen_info.texture.gl_format,
-                        screen_info.texture.gl_type, gl_framebuffer_data.data());
-
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
-}
-
-void RendererOpenGL::LoadColorToActiveGLTexture(u8 color_r, u8 color_g, u8 color_b, u8 color_a,
-                                                const TextureInfo& texture) {
-    const u8 framebuffer_data[4] = {color_a, color_b, color_g, color_r};
-    glClearTexImage(texture.resource.handle, 0, GL_RGBA, GL_UNSIGNED_BYTE, framebuffer_data);
-}
-
-void RendererOpenGL::InitOpenGLObjects() {
-    // Create shader programs
-    fxaa_vertex = CreateProgram(HostShaders::FXAA_VERT, GL_VERTEX_SHADER);
-    fxaa_fragment = CreateProgram(HostShaders::FXAA_FRAG, GL_FRAGMENT_SHADER);
-
-    const auto replace_include = [](std::string& shader_source, std::string_view include_name,
-                                    std::string_view include_content) {
-        const std::string include_string = fmt::format("#include \"{}\"", include_name);
-        const std::size_t pos = shader_source.find(include_string);
-        ASSERT(pos != std::string::npos);
-        shader_source.replace(pos, include_string.size(), include_content);
-    };
-
-    const auto SmaaShader = [&](std::string_view specialized_source, GLenum stage) {
-        std::string shader_source{specialized_source};
-        replace_include(shader_source, "opengl_smaa.glsl", HostShaders::OPENGL_SMAA_GLSL);
-        return CreateProgram(shader_source, stage);
-    };
-
-    smaa_edge_detection_vert = SmaaShader(HostShaders::SMAA_EDGE_DETECTION_VERT, GL_VERTEX_SHADER);
-    smaa_edge_detection_frag =
-        SmaaShader(HostShaders::SMAA_EDGE_DETECTION_FRAG, GL_FRAGMENT_SHADER);
-    smaa_blending_weight_calculation_vert =
-        SmaaShader(HostShaders::SMAA_BLENDING_WEIGHT_CALCULATION_VERT, GL_VERTEX_SHADER);
-    smaa_blending_weight_calculation_frag =
-        SmaaShader(HostShaders::SMAA_BLENDING_WEIGHT_CALCULATION_FRAG, GL_FRAGMENT_SHADER);
-    smaa_neighborhood_blending_vert =
-        SmaaShader(HostShaders::SMAA_NEIGHBORHOOD_BLENDING_VERT, GL_VERTEX_SHADER);
-    smaa_neighborhood_blending_frag =
-        SmaaShader(HostShaders::SMAA_NEIGHBORHOOD_BLENDING_FRAG, GL_FRAGMENT_SHADER);
-
-    present_vertex = CreateProgram(HostShaders::OPENGL_PRESENT_VERT, GL_VERTEX_SHADER);
-    present_bilinear_fragment = CreateProgram(HostShaders::OPENGL_PRESENT_FRAG, GL_FRAGMENT_SHADER);
-    present_bicubic_fragment = CreateProgram(HostShaders::PRESENT_BICUBIC_FRAG, GL_FRAGMENT_SHADER);
-    present_gaussian_fragment =
-        CreateProgram(HostShaders::PRESENT_GAUSSIAN_FRAG, GL_FRAGMENT_SHADER);
-    present_scaleforce_fragment =
-        CreateProgram(fmt::format("#version 460\n{}", HostShaders::OPENGL_PRESENT_SCALEFORCE_FRAG),
-                      GL_FRAGMENT_SHADER);
-
-    std::string fsr_source{HostShaders::OPENGL_FIDELITYFX_FSR_FRAG};
-    replace_include(fsr_source, "ffx_a.h", HostShaders::FFX_A_H);
-    replace_include(fsr_source, "ffx_fsr1.h", HostShaders::FFX_FSR1_H);
-
-    std::string fsr_easu_frag_source{HostShaders::OPENGL_FIDELITYFX_FSR_EASU_FRAG};
-    std::string fsr_rcas_frag_source{HostShaders::OPENGL_FIDELITYFX_FSR_RCAS_FRAG};
-    replace_include(fsr_easu_frag_source, "opengl_fidelityfx_fsr.frag", fsr_source);
-    replace_include(fsr_rcas_frag_source, "opengl_fidelityfx_fsr.frag", fsr_source);
-
-    fsr = std::make_unique<FSR>(HostShaders::FULL_SCREEN_TRIANGLE_VERT, fsr_easu_frag_source,
-                                fsr_rcas_frag_source);
-
-    // Generate presentation sampler
-    present_sampler.Create();
-    glSamplerParameteri(present_sampler.handle, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glSamplerParameteri(present_sampler.handle, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glSamplerParameteri(present_sampler.handle, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glSamplerParameteri(present_sampler.handle, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glSamplerParameteri(present_sampler.handle, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
-
-    present_sampler_nn.Create();
-    glSamplerParameteri(present_sampler_nn.handle, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glSamplerParameteri(present_sampler_nn.handle, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glSamplerParameteri(present_sampler_nn.handle, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glSamplerParameteri(present_sampler_nn.handle, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glSamplerParameteri(present_sampler_nn.handle, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
-
-    // Generate VBO handle for drawing
-    vertex_buffer.Create();
-
-    // Attach vertex data to VAO
-    glNamedBufferData(vertex_buffer.handle, sizeof(ScreenRectVertex) * 4, nullptr, GL_STREAM_DRAW);
-
-    // Allocate textures for the screen
-    screen_info.texture.resource.Create(GL_TEXTURE_2D);
-
-    const GLuint texture = screen_info.texture.resource.handle;
-    glTextureStorage2D(texture, 1, GL_RGBA8, 1, 1);
-
-    screen_info.display_texture = screen_info.texture.resource.handle;
-
-    // Clear screen to black
-    LoadColorToActiveGLTexture(0, 0, 0, 0, screen_info.texture);
-
-    aa_framebuffer.Create();
-
-    smaa_area_tex.Create(GL_TEXTURE_2D);
-    glTextureStorage2D(smaa_area_tex.handle, 1, GL_RG8, AREATEX_WIDTH, AREATEX_HEIGHT);
-    glTextureSubImage2D(smaa_area_tex.handle, 0, 0, 0, AREATEX_WIDTH, AREATEX_HEIGHT, GL_RG,
-                        GL_UNSIGNED_BYTE, areaTexBytes);
-    smaa_search_tex.Create(GL_TEXTURE_2D);
-    glTextureStorage2D(smaa_search_tex.handle, 1, GL_R8, SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT);
-    glTextureSubImage2D(smaa_search_tex.handle, 0, 0, 0, SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT, GL_RED,
-                        GL_UNSIGNED_BYTE, searchTexBytes);
-}
-
 void RendererOpenGL::AddTelemetryFields() {
     const char* const gl_version{reinterpret_cast<char const*>(glGetString(GL_VERSION))};
     const char* const gpu_vendor{reinterpret_cast<char const*>(glGetString(GL_VENDOR))};
@@ -380,328 +159,7 @@ void RendererOpenGL::AddTelemetryFields() {
     telemetry_session.AddField(user_system, "GPU_OpenGL_Version", std::string(gl_version));
 }
 
-void RendererOpenGL::ConfigureFramebufferTexture(TextureInfo& texture,
-                                                 const Tegra::FramebufferConfig& framebuffer) {
-    texture.width = framebuffer.width;
-    texture.height = framebuffer.height;
-    texture.pixel_format = framebuffer.pixel_format;
-
-    const auto pixel_format{
-        VideoCore::Surface::PixelFormatFromGPUPixelFormat(framebuffer.pixel_format)};
-    const u32 bytes_per_pixel{VideoCore::Surface::BytesPerBlock(pixel_format)};
-    gl_framebuffer_data.resize(texture.width * texture.height * bytes_per_pixel);
-
-    GLint internal_format;
-    switch (framebuffer.pixel_format) {
-    case Service::android::PixelFormat::Rgba8888:
-        internal_format = GL_RGBA8;
-        texture.gl_format = GL_RGBA;
-        texture.gl_type = GL_UNSIGNED_INT_8_8_8_8_REV;
-        break;
-    case Service::android::PixelFormat::Rgb565:
-        internal_format = GL_RGB565;
-        texture.gl_format = GL_RGB;
-        texture.gl_type = GL_UNSIGNED_SHORT_5_6_5;
-        break;
-    default:
-        internal_format = GL_RGBA8;
-        texture.gl_format = GL_RGBA;
-        texture.gl_type = GL_UNSIGNED_INT_8_8_8_8_REV;
-        // UNIMPLEMENTED_MSG("Unknown framebuffer pixel format: {}",
-        //                   static_cast<u32>(framebuffer.pixel_format));
-        break;
-    }
-
-    texture.resource.Release();
-    texture.resource.Create(GL_TEXTURE_2D);
-    glTextureStorage2D(texture.resource.handle, 1, internal_format, texture.width, texture.height);
-    aa_texture.Release();
-    aa_texture.Create(GL_TEXTURE_2D);
-    glTextureStorage2D(aa_texture.handle, 1, GL_RGBA16F,
-                       Settings::values.resolution_info.ScaleUp(screen_info.texture.width),
-                       Settings::values.resolution_info.ScaleUp(screen_info.texture.height));
-    glNamedFramebufferTexture(aa_framebuffer.handle, GL_COLOR_ATTACHMENT0, aa_texture.handle, 0);
-    smaa_edges_tex.Release();
-    smaa_edges_tex.Create(GL_TEXTURE_2D);
-    glTextureStorage2D(smaa_edges_tex.handle, 1, GL_RG16F,
-                       Settings::values.resolution_info.ScaleUp(screen_info.texture.width),
-                       Settings::values.resolution_info.ScaleUp(screen_info.texture.height));
-    smaa_blend_tex.Release();
-    smaa_blend_tex.Create(GL_TEXTURE_2D);
-    glTextureStorage2D(smaa_blend_tex.handle, 1, GL_RGBA16F,
-                       Settings::values.resolution_info.ScaleUp(screen_info.texture.width),
-                       Settings::values.resolution_info.ScaleUp(screen_info.texture.height));
-}
-
-void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
-    // TODO: Signal state tracker about these changes
-    state_tracker.NotifyScreenDrawVertexArray();
-    state_tracker.NotifyPolygonModes();
-    state_tracker.NotifyViewport0();
-    state_tracker.NotifyScissor0();
-    state_tracker.NotifyColorMask(0);
-    state_tracker.NotifyBlend0();
-    state_tracker.NotifyFramebuffer();
-    state_tracker.NotifyFrontFace();
-    state_tracker.NotifyCullTest();
-    state_tracker.NotifyDepthTest();
-    state_tracker.NotifyStencilTest();
-    state_tracker.NotifyPolygonOffset();
-    state_tracker.NotifyRasterizeEnable();
-    state_tracker.NotifyFramebufferSRGB();
-    state_tracker.NotifyLogicOp();
-    state_tracker.NotifyClipControl();
-    state_tracker.NotifyAlphaTest();
-
-    state_tracker.ClipControl(GL_LOWER_LEFT, GL_ZERO_TO_ONE);
-
-    glEnable(GL_CULL_FACE);
-    glDisable(GL_COLOR_LOGIC_OP);
-    glDisable(GL_DEPTH_TEST);
-    glDisable(GL_STENCIL_TEST);
-    glDisable(GL_POLYGON_OFFSET_FILL);
-    glDisable(GL_RASTERIZER_DISCARD);
-    glDisable(GL_ALPHA_TEST);
-    glDisablei(GL_BLEND, 0);
-    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-    glCullFace(GL_BACK);
-    glFrontFace(GL_CW);
-    glColorMaski(0, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-    glDepthRangeIndexed(0, 0.0, 0.0);
-
-    glBindTextureUnit(0, screen_info.display_texture);
-
-    auto anti_aliasing = Settings::values.anti_aliasing.GetValue();
-    if (anti_aliasing >= Settings::AntiAliasing::MaxEnum) {
-        LOG_ERROR(Render_OpenGL, "Invalid antialiasing option selected {}", anti_aliasing);
-        anti_aliasing = Settings::AntiAliasing::None;
-        Settings::values.anti_aliasing.SetValue(anti_aliasing);
-    }
-
-    if (anti_aliasing != Settings::AntiAliasing::None) {
-        glEnablei(GL_SCISSOR_TEST, 0);
-        auto viewport_width = screen_info.texture.width;
-        auto scissor_width = framebuffer_crop_rect.GetWidth();
-        if (scissor_width <= 0) {
-            scissor_width = viewport_width;
-        }
-        auto viewport_height = screen_info.texture.height;
-        auto scissor_height = framebuffer_crop_rect.GetHeight();
-        if (scissor_height <= 0) {
-            scissor_height = viewport_height;
-        }
-        if (screen_info.was_accelerated) {
-            viewport_width = Settings::values.resolution_info.ScaleUp(viewport_width);
-            scissor_width = Settings::values.resolution_info.ScaleUp(scissor_width);
-            viewport_height = Settings::values.resolution_info.ScaleUp(viewport_height);
-            scissor_height = Settings::values.resolution_info.ScaleUp(scissor_height);
-        }
-        glScissorIndexed(0, 0, 0, scissor_width, scissor_height);
-        glViewportIndexedf(0, 0.0f, 0.0f, static_cast<GLfloat>(viewport_width),
-                           static_cast<GLfloat>(viewport_height));
-
-        glBindSampler(0, present_sampler.handle);
-        GLint old_read_fb;
-        GLint old_draw_fb;
-        glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &old_read_fb);
-        glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &old_draw_fb);
-
-        switch (anti_aliasing) {
-        case Settings::AntiAliasing::Fxaa: {
-            program_manager.BindPresentPrograms(fxaa_vertex.handle, fxaa_fragment.handle);
-            glBindFramebuffer(GL_DRAW_FRAMEBUFFER, aa_framebuffer.handle);
-            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-        } break;
-        case Settings::AntiAliasing::Smaa: {
-            glClearColor(0, 0, 0, 0);
-            glFrontFace(GL_CCW);
-            glBindFramebuffer(GL_DRAW_FRAMEBUFFER, aa_framebuffer.handle);
-            glBindSampler(1, present_sampler.handle);
-            glBindSampler(2, present_sampler.handle);
-
-            glNamedFramebufferTexture(aa_framebuffer.handle, GL_COLOR_ATTACHMENT0,
-                                      smaa_edges_tex.handle, 0);
-            glClear(GL_COLOR_BUFFER_BIT);
-            program_manager.BindPresentPrograms(smaa_edge_detection_vert.handle,
-                                                smaa_edge_detection_frag.handle);
-            glDrawArrays(GL_TRIANGLES, 0, 3);
-
-            glBindTextureUnit(0, smaa_edges_tex.handle);
-            glBindTextureUnit(1, smaa_area_tex.handle);
-            glBindTextureUnit(2, smaa_search_tex.handle);
-            glNamedFramebufferTexture(aa_framebuffer.handle, GL_COLOR_ATTACHMENT0,
-                                      smaa_blend_tex.handle, 0);
-            glClear(GL_COLOR_BUFFER_BIT);
-            program_manager.BindPresentPrograms(smaa_blending_weight_calculation_vert.handle,
-                                                smaa_blending_weight_calculation_frag.handle);
-            glDrawArrays(GL_TRIANGLES, 0, 3);
-
-            glBindTextureUnit(0, screen_info.display_texture);
-            glBindTextureUnit(1, smaa_blend_tex.handle);
-            glNamedFramebufferTexture(aa_framebuffer.handle, GL_COLOR_ATTACHMENT0,
-                                      aa_texture.handle, 0);
-            program_manager.BindPresentPrograms(smaa_neighborhood_blending_vert.handle,
-                                                smaa_neighborhood_blending_frag.handle);
-            glDrawArrays(GL_TRIANGLES, 0, 3);
-            glFrontFace(GL_CW);
-        } break;
-        default:
-            UNREACHABLE();
-        }
-
-        glBindFramebuffer(GL_READ_FRAMEBUFFER, old_read_fb);
-        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, old_draw_fb);
-
-        glBindTextureUnit(0, aa_texture.handle);
-    }
-    glDisablei(GL_SCISSOR_TEST, 0);
-
-    if (Settings::values.scaling_filter.GetValue() == Settings::ScalingFilter::Fsr) {
-        if (!fsr->AreBuffersInitialized()) {
-            fsr->InitBuffers();
-        }
-
-        auto crop_rect = framebuffer_crop_rect;
-        if (crop_rect.GetWidth() == 0) {
-            crop_rect.right = framebuffer_width;
-        }
-        if (crop_rect.GetHeight() == 0) {
-            crop_rect.bottom = framebuffer_height;
-        }
-        crop_rect = crop_rect.Scale(Settings::values.resolution_info.up_factor);
-        const auto fsr_input_width = Settings::values.resolution_info.ScaleUp(framebuffer_width);
-        const auto fsr_input_height = Settings::values.resolution_info.ScaleUp(framebuffer_height);
-        glBindSampler(0, present_sampler.handle);
-        fsr->Draw(program_manager, layout.screen, fsr_input_width, fsr_input_height, crop_rect);
-    } else {
-        if (fsr->AreBuffersInitialized()) {
-            fsr->ReleaseBuffers();
-        }
-    }
-
-    const std::array ortho_matrix =
-        MakeOrthographicMatrix(static_cast<float>(layout.width), static_cast<float>(layout.height));
-
-    const auto fragment_handle = [this]() {
-        switch (Settings::values.scaling_filter.GetValue()) {
-        case Settings::ScalingFilter::NearestNeighbor:
-        case Settings::ScalingFilter::Bilinear:
-            return present_bilinear_fragment.handle;
-        case Settings::ScalingFilter::Bicubic:
-            return present_bicubic_fragment.handle;
-        case Settings::ScalingFilter::Gaussian:
-            return present_gaussian_fragment.handle;
-        case Settings::ScalingFilter::ScaleForce:
-            return present_scaleforce_fragment.handle;
-        case Settings::ScalingFilter::Fsr:
-            return fsr->GetPresentFragmentProgram().handle;
-        default:
-            return present_bilinear_fragment.handle;
-        }
-    }();
-    program_manager.BindPresentPrograms(present_vertex.handle, fragment_handle);
-    glProgramUniformMatrix3x2fv(present_vertex.handle, ModelViewMatrixLocation, 1, GL_FALSE,
-                                ortho_matrix.data());
-
-    const auto& texcoords = screen_info.display_texcoords;
-    auto left = texcoords.left;
-    auto right = texcoords.right;
-    if (framebuffer_transform_flags != Service::android::BufferTransformFlags::Unset) {
-        if (framebuffer_transform_flags == Service::android::BufferTransformFlags::FlipV) {
-            // Flip the framebuffer vertically
-            left = texcoords.right;
-            right = texcoords.left;
-        } else {
-            // Other transformations are unsupported
-            LOG_CRITICAL(Render_OpenGL, "Unsupported framebuffer_transform_flags={}",
-                         framebuffer_transform_flags);
-            UNIMPLEMENTED();
-        }
-    }
-
-    ASSERT_MSG(framebuffer_crop_rect.left == 0, "Unimplemented");
-
-    f32 left_start{};
-    if (framebuffer_crop_rect.Top() > 0) {
-        left_start = static_cast<f32>(framebuffer_crop_rect.Top()) /
-                     static_cast<f32>(framebuffer_crop_rect.Bottom());
-    }
-    f32 scale_u = static_cast<f32>(framebuffer_width) / static_cast<f32>(screen_info.texture.width);
-    f32 scale_v =
-        static_cast<f32>(framebuffer_height) / static_cast<f32>(screen_info.texture.height);
-
-    if (Settings::values.scaling_filter.GetValue() != Settings::ScalingFilter::Fsr) {
-        // Scale the output by the crop width/height. This is commonly used with 1280x720 rendering
-        // (e.g. handheld mode) on a 1920x1080 framebuffer.
-        if (framebuffer_crop_rect.GetWidth() > 0) {
-            scale_u = static_cast<f32>(framebuffer_crop_rect.GetWidth()) /
-                      static_cast<f32>(screen_info.texture.width);
-        }
-        if (framebuffer_crop_rect.GetHeight() > 0) {
-            scale_v = static_cast<f32>(framebuffer_crop_rect.GetHeight()) /
-                      static_cast<f32>(screen_info.texture.height);
-        }
-    }
-    if (Settings::values.anti_aliasing.GetValue() == Settings::AntiAliasing::Fxaa &&
-        !screen_info.was_accelerated) {
-        scale_u /= Settings::values.resolution_info.up_factor;
-        scale_v /= Settings::values.resolution_info.up_factor;
-    }
-
-    const auto& screen = layout.screen;
-    const std::array vertices = {
-        ScreenRectVertex(screen.left, screen.top, texcoords.top * scale_u,
-                         left_start + left * scale_v),
-        ScreenRectVertex(screen.right, screen.top, texcoords.bottom * scale_u,
-                         left_start + left * scale_v),
-        ScreenRectVertex(screen.left, screen.bottom, texcoords.top * scale_u,
-                         left_start + right * scale_v),
-        ScreenRectVertex(screen.right, screen.bottom, texcoords.bottom * scale_u,
-                         left_start + right * scale_v),
-    };
-    glNamedBufferSubData(vertex_buffer.handle, 0, sizeof(vertices), std::data(vertices));
-
-    glDisable(GL_FRAMEBUFFER_SRGB);
-    glViewportIndexedf(0, 0.0f, 0.0f, static_cast<GLfloat>(layout.width),
-                       static_cast<GLfloat>(layout.height));
-
-    glEnableVertexAttribArray(PositionLocation);
-    glEnableVertexAttribArray(TexCoordLocation);
-    glVertexAttribDivisor(PositionLocation, 0);
-    glVertexAttribDivisor(TexCoordLocation, 0);
-    glVertexAttribFormat(PositionLocation, 2, GL_FLOAT, GL_FALSE,
-                         offsetof(ScreenRectVertex, position));
-    glVertexAttribFormat(TexCoordLocation, 2, GL_FLOAT, GL_FALSE,
-                         offsetof(ScreenRectVertex, tex_coord));
-    glVertexAttribBinding(PositionLocation, 0);
-    glVertexAttribBinding(TexCoordLocation, 0);
-    if (device.HasVertexBufferUnifiedMemory()) {
-        glBindVertexBuffer(0, 0, 0, sizeof(ScreenRectVertex));
-        glBufferAddressRangeNV(GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV, 0, vertex_buffer_address,
-                               sizeof(vertices));
-    } else {
-        glBindVertexBuffer(0, vertex_buffer.handle, 0, sizeof(ScreenRectVertex));
-    }
-
-    if (Settings::values.scaling_filter.GetValue() != Settings::ScalingFilter::NearestNeighbor) {
-        glBindSampler(0, present_sampler.handle);
-    } else {
-        glBindSampler(0, present_sampler_nn.handle);
-    }
-
-    // Update background color before drawing
-    glClearColor(Settings::values.bg_red.GetValue() / 255.0f,
-                 Settings::values.bg_green.GetValue() / 255.0f,
-                 Settings::values.bg_blue.GetValue() / 255.0f, 1.0f);
-
-    glClear(GL_COLOR_BUFFER_BIT);
-    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-
-    // TODO
-    // program_manager.RestoreGuestPipeline();
-}
-
-void RendererOpenGL::RenderScreenshot() {
+void RendererOpenGL::RenderScreenshot(std::span<const Tegra::FramebufferConfig> framebuffers) {
     if (!renderer_settings.screenshot_requested) {
         return;
     }
@@ -723,7 +181,7 @@ void RendererOpenGL::RenderScreenshot() {
     glRenderbufferStorage(GL_RENDERBUFFER, GL_SRGB8, layout.width, layout.height);
     glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer);
 
-    DrawScreen(layout);
+    blit_screen->DrawScreen(framebuffers, layout);
 
     glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
     glPixelStorei(GL_PACK_ROW_LENGTH, 0);

src/video_core/renderer_opengl/renderer_opengl.h

@@ -10,7 +10,6 @@
 
 #include "video_core/renderer_base.h"
 #include "video_core/renderer_opengl/gl_device.h"
-#include "video_core/renderer_opengl/gl_fsr.h"
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/gl_shader_manager.h"
@@ -25,37 +24,13 @@ namespace Core::Frontend {
 class EmuWindow;
 }
 
-namespace Core::Memory {
-class Memory;
-}
-
-namespace Layout {
-struct FramebufferLayout;
-}
-
 namespace Tegra {
 class GPU;
 }
 
 namespace OpenGL {
 
-/// Structure used for storing information about the textures for the Switch screen
-struct TextureInfo {
-    OGLTexture resource;
-    GLsizei width;
-    GLsizei height;
-    GLenum gl_format;
-    GLenum gl_type;
-    Service::android::PixelFormat pixel_format;
-};
-
-/// Structure used for storing information about the display target for the Switch screen
-struct ScreenInfo {
-    GLuint display_texture{};
-    bool was_accelerated = false;
-    const Common::Rectangle<float> display_texcoords{0.0f, 0.0f, 1.0f, 1.0f};
-    TextureInfo texture;
-};
+class BlitScreen;
 
 class RendererOpenGL final : public VideoCore::RendererBase {
 public:
@@ -65,7 +40,7 @@ public:
                             std::unique_ptr<Core::Frontend::GraphicsContext> context_);
     ~RendererOpenGL() override;
 
-    void SwapBuffers(const Tegra::FramebufferConfig* framebuffer) override;
+    void Composite(std::span<const Tegra::FramebufferConfig> framebuffers) override;
 
     VideoCore::RasterizerInterface* ReadRasterizer() override {
         return &rasterizer;
@@ -76,28 +51,8 @@ public:
     }
 
 private:
-    /// Initializes the OpenGL state and creates persistent objects.
-    void InitOpenGLObjects();
-
     void AddTelemetryFields();
-
-    void ConfigureFramebufferTexture(TextureInfo& texture,
-                                     const Tegra::FramebufferConfig& framebuffer);
-
-    /// Draws the emulated screens to the emulator window.
-    void DrawScreen(const Layout::FramebufferLayout& layout);
-
-    void RenderScreenshot();
-
-    /// Loads framebuffer from emulated memory into the active OpenGL texture.
-    void LoadFBToScreenInfo(const Tegra::FramebufferConfig& framebuffer);
-
-    /// Fills active OpenGL texture with the given RGB color.Since the color is solid, the texture
-    /// can be 1x1 but will stretch across whatever it's rendered on.
-    void LoadColorToActiveGLTexture(u8 color_r, u8 color_g, u8 color_b, u8 color_a,
-                                    const TextureInfo& texture);
-
-    void PrepareRendertarget(const Tegra::FramebufferConfig* framebuffer);
+    void RenderScreenshot(std::span<const Tegra::FramebufferConfig> framebuffers);
 
     Core::TelemetrySession& telemetry_session;
     Core::Frontend::EmuWindow& emu_window;
@@ -108,49 +63,9 @@ private:
     StateTracker state_tracker;
     ProgramManager program_manager;
     RasterizerOpenGL rasterizer;
-
-    // OpenGL object IDs
-    OGLSampler present_sampler;
-    OGLSampler present_sampler_nn;
-    OGLBuffer vertex_buffer;
-    OGLProgram fxaa_vertex;
-    OGLProgram fxaa_fragment;
-    OGLProgram present_vertex;
-    OGLProgram present_bilinear_fragment;
-    OGLProgram present_bicubic_fragment;
-    OGLProgram present_gaussian_fragment;
-    OGLProgram present_scaleforce_fragment;
     OGLFramebuffer screenshot_framebuffer;
 
-    // GPU address of the vertex buffer
-    GLuint64EXT vertex_buffer_address = 0;
-
-    /// Display information for Switch screen
-    ScreenInfo screen_info;
-    OGLTexture aa_texture;
-    OGLFramebuffer aa_framebuffer;
-
-    OGLProgram smaa_edge_detection_vert;
-    OGLProgram smaa_blending_weight_calculation_vert;
-    OGLProgram smaa_neighborhood_blending_vert;
-    OGLProgram smaa_edge_detection_frag;
-    OGLProgram smaa_blending_weight_calculation_frag;
-    OGLProgram smaa_neighborhood_blending_frag;
-    OGLTexture smaa_area_tex;
-    OGLTexture smaa_search_tex;
-    OGLTexture smaa_edges_tex;
-    OGLTexture smaa_blend_tex;
-
-    std::unique_ptr<FSR> fsr;
-
-    /// OpenGL framebuffer data
-    std::vector<u8> gl_framebuffer_data;
-
-    /// Used for transforming the framebuffer orientation
-    Service::android::BufferTransformFlags framebuffer_transform_flags{};
-    Common::Rectangle<int> framebuffer_crop_rect;
-    u32 framebuffer_width;
-    u32 framebuffer_height;
+    std::unique_ptr<BlitScreen> blit_screen;
 };
 
 } // namespace OpenGL