wip

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

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

@@ -750,8 +750,6 @@
 
     <!-- Anti-Aliasing -->
     <string name="anti_aliasing_none">هیچ</string>
-    <string name="anti_aliasing_fxaa">FXAA</string>
-    <string name="anti_aliasing_smaa">SMAA</string>
 
     <!-- Screen Layouts -->
     <string name="screen_layout_auto">خودکار</string>

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

@@ -266,6 +266,7 @@
         <item>@string/anti_aliasing_none</item>
         <item>@string/anti_aliasing_fxaa</item>
         <item>@string/anti_aliasing_smaa</item>
+        <item>@string/anti_aliasing_ssaa</item>
     </string-array>
 
     <integer-array name="rendererAntiAliasingValues">

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

@@ -1087,6 +1087,7 @@
     <string name="anti_aliasing_none">None</string>
     <string name="anti_aliasing_fxaa" translatable="false">FXAA</string>
     <string name="anti_aliasing_smaa" translatable="false">SMAA</string>
+    <string name="anti_aliasing_smaa" translatable="false">SSAA</string>
 
     <!-- Screen Layouts -->
     <string name="screen_layout_auto">Auto</string>

src/common/settings_enums.h

@@ -146,7 +146,7 @@ ENUM(FullscreenMode, Borderless, Exclusive);
 ENUM(NvdecEmulation, Off, Cpu, Gpu);
 ENUM(ResolutionSetup, Res1_4X, Res1_2X, Res3_4X, Res1X, Res5_4X, Res3_2X, Res2X, Res3X, Res4X, Res5X, Res6X, Res7X, Res8X);
 ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, Gaussian, Lanczos, ScaleForce, Fsr, Area, ZeroTangent, BSpline, Mitchell, Spline1, Mmpx, Sgsr, SgsrEdge, MaxEnum);
-ENUM(AntiAliasing, None, Fxaa, Smaa, MaxEnum);
+ENUM(AntiAliasing, None, Fxaa, Smaa, Ssaa, MaxEnum);
 ENUM(AspectRatio, R16_9, R4_3, R21_9, R16_10, Stretch);
 ENUM(ConsoleMode, Handheld, Docked);
 ENUM(AppletMode, HLE, LLE);

src/qt_common/config/shared_translation.cpp

@@ -500,6 +500,7 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {
                               PAIR(AntiAliasing, None, tr("None")),
                               PAIR(AntiAliasing, Fxaa, tr("FXAA")),
                               PAIR(AntiAliasing, Smaa, tr("SMAA")),
+                              PAIR(AntiAliasing, Ssaa, tr("SSAA")),
                           }});
     translations->insert({Settings::EnumMetadata<Settings::AspectRatio>::Index(),
                           {

src/qt_common/config/shared_translation.h

@@ -31,6 +31,7 @@ static const std::map<Settings::AntiAliasing, QString> anti_aliasing_texts_map =
     {Settings::AntiAliasing::None, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "None"))},
     {Settings::AntiAliasing::Fxaa, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "FXAA"))},
     {Settings::AntiAliasing::Smaa, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "SMAA"))},
+    {Settings::AntiAliasing::Ssaa, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "SSAA"))},
 };
 
 static const std::map<Settings::ScalingFilter, QString> scaling_filter_texts_map = {

src/video_core/CMakeLists.txt

@@ -125,6 +125,8 @@ add_library(video_core STATIC
     renderer_vulkan/present/fsr.h
     renderer_vulkan/present/fxaa.cpp
     renderer_vulkan/present/fxaa.h
+    renderer_vulkan/present/ssaa.cpp
+    renderer_vulkan/present/ssaa.h
     renderer_vulkan/present/layer.cpp
     renderer_vulkan/present/layer.h
     renderer_vulkan/present/present_push_constants.h

src/video_core/host_shaders/CMakeLists.txt

@@ -60,6 +60,8 @@ set(SHADER_FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/smaa_blending_weight_calculation.frag
     ${CMAKE_CURRENT_SOURCE_DIR}/smaa_neighborhood_blending.vert
     ${CMAKE_CURRENT_SOURCE_DIR}/smaa_neighborhood_blending.frag
+    ${CMAKE_CURRENT_SOURCE_DIR}/ssaa.frag
+    ${CMAKE_CURRENT_SOURCE_DIR}/ssaa.vert
     ${CMAKE_CURRENT_SOURCE_DIR}/vulkan_blit_depth_stencil.frag
     ${CMAKE_CURRENT_SOURCE_DIR}/vulkan_color_clear.frag
     ${CMAKE_CURRENT_SOURCE_DIR}/vulkan_color_clear.vert

src/video_core/host_shaders/ssaa.frag

@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 460
+#extension GL_ARB_sample_shading : enable
+
+#ifdef VULKAN
+#define BINDING_COLOR_TEXTURE 1
+#else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
+#define BINDING_COLOR_TEXTURE 0
+#endif
+
+layout (location = 0) out vec4 frag_color;
+layout (binding = BINDING_COLOR_TEXTURE) uniform sampler2DMS input_texture;
+
+void main() {
+    frag_color = texelFetch(input_texture, ivec2(gl_FragCoord.xy), gl_SampleID);
+}

src/video_core/host_shaders/ssaa.vert

@@ -0,0 +1,21 @@
+// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 450
+
+#ifdef VULKAN
+#define VERTEX_ID gl_VertexIndex
+#define FLIPY 1
+#else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
+#define VERTEX_ID gl_VertexID
+#define FLIPY -1
+out gl_PerVertex {
+    vec4 gl_Position;
+};
+#endif
+
+void main() {
+    float x = float((VERTEX_ID & 1) << 2);
+    float y = float((VERTEX_ID & 2) << 1);
+    gl_Position = vec4(x - 1.0, FLIPY * (y - 1.0), 0.0, 1.0);
+}

src/video_core/renderer_vulkan/present/layer.cpp

@@ -111,6 +111,8 @@ void Layer::ConfigureDraw(PresentPushConstants* out_push_constants,
         fxaa->Draw(scheduler, image_index, &source_image, &source_image_view);
     } else if (auto* smaa = std::get_if<SMAA>(&anti_alias)) {
         smaa->Draw(scheduler, image_index, &source_image, &source_image_view);
+    } else if (auto* ssaa = std::get_if<SSAA>(&anti_alias)) {
+        ssaa->Draw(scheduler, image_index, &source_image, &source_image_view);
     }
 
     auto crop_rect = Tegra::NormalizeCrop(framebuffer, texture_width, texture_height);
@@ -206,6 +208,9 @@ void Layer::SetAntiAliasPass() {
     case Settings::AntiAliasing::Smaa:
         anti_alias.emplace<SMAA>(device, memory_allocator, image_count, render_area);
         break;
+    case Settings::AntiAliasing::Ssaa:
+        anti_alias.emplace<SSAA>(device, memory_allocator, image_count, render_area);
+        break;
     default:
         anti_alias.emplace<std::monostate>();
         break;

src/video_core/renderer_vulkan/present/layer.h

@@ -16,6 +16,7 @@
 #include "video_core/renderer_vulkan/present/sgsr.h"
 #include "video_core/renderer_vulkan/present/fxaa.h"
 #include "video_core/renderer_vulkan/present/smaa.h"
+#include "video_core/renderer_vulkan/present/ssaa.h"
 
 namespace Layout {
 struct FramebufferLayout;
@@ -95,7 +96,7 @@ private:
     Service::android::PixelFormat pixel_format{};
 
     Settings::AntiAliasing anti_alias_setting{};
-    std::variant<std::monostate, FXAA, SMAA> anti_alias{};
+    std::variant<std::monostate, FXAA, SMAA, SSAA> anti_alias{};
     std::variant<std::monostate, SGSR, FSR> sr_filter{};
     std::vector<u64> resource_ticks{};
 };

src/video_core/renderer_vulkan/present/ssaa.cpp

@@ -0,0 +1,316 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/common_types.h"
+
+#include "video_core/host_shaders/ssaa_frag_spv.h"
+#include "video_core/host_shaders/ssaa_vert_spv.h"
+#include "video_core/renderer_vulkan/present/ssaa.h"
+#include "video_core/renderer_vulkan/present/util.h"
+#include "video_core/renderer_vulkan/vk_scheduler.h"
+#include "video_core/renderer_vulkan/vk_shader_util.h"
+#include "video_core/vulkan_common/vulkan_device.h"
+#include "vulkan/vulkan_core.h"
+
+namespace Vulkan {
+
+SSAA::SSAA(const Device& device, MemoryAllocator& allocator, size_t image_count, VkExtent2D extent)
+    : m_device(device), m_allocator(allocator), m_extent(extent)
+    , m_image_count(u32(image_count))
+{
+    CreateImages();
+    CreateRenderPasses();
+    CreateSampler();
+    CreateShaders();
+    CreateDescriptorPool();
+    CreateDescriptorSetLayouts();
+    CreateDescriptorSets();
+    CreatePipelineLayouts();
+    CreatePipelines();
+}
+
+SSAA::~SSAA() = default;
+
+void SSAA::CreateImages() {
+    for (u32 i = 0; i < m_image_count; i++) {
+        Image& image = m_dynamic_images.emplace_back();
+        image.image = m_allocator.CreateImage(VkImageCreateInfo{
+            .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+            .pNext = nullptr,
+            .flags = 0,
+            .imageType = VK_IMAGE_TYPE_2D,
+            .format = VK_FORMAT_R8G8B8A8_UNORM,
+            .extent = {.width = m_extent.width, .height = m_extent.height, .depth = 1},
+            .mipLevels = 1,
+            .arrayLayers = 1,
+            .samples = VK_SAMPLE_COUNT_2_BIT,
+            .tiling = VK_IMAGE_TILING_OPTIMAL,
+            .usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+            .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+            .queueFamilyIndexCount = 0,
+            .pQueueFamilyIndices = nullptr,
+            .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
+        });
+        image.image_view = CreateWrappedImageView(m_device, image.image, VK_FORMAT_R8G8B8A8_UNORM);
+    }
+}
+
+void SSAA::CreateRenderPasses() {
+    const VkAttachmentDescription attachment{
+        .flags = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT,
+        .format = VK_FORMAT_R8G8B8A8_UNORM,
+        .samples = VK_SAMPLE_COUNT_2_BIT,
+        .loadOp = VK_ATTACHMENT_LOAD_OP_LOAD,
+        .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
+        .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD,
+        .stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE,
+        .initialLayout = VK_IMAGE_LAYOUT_GENERAL,
+        .finalLayout = VK_IMAGE_LAYOUT_GENERAL,
+    };
+    constexpr VkAttachmentReference color_attachment_ref{
+        .attachment = 0,
+        .layout = VK_IMAGE_LAYOUT_GENERAL,
+    };
+    const VkSubpassDescription subpass_description{
+        .flags = 0,
+        .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
+        .inputAttachmentCount = 0,
+        .pInputAttachments = nullptr,
+        .colorAttachmentCount = 1,
+        .pColorAttachments = &color_attachment_ref,
+        .pResolveAttachments = nullptr,
+        .pDepthStencilAttachment = nullptr,
+        .preserveAttachmentCount = 0,
+        .pPreserveAttachments = nullptr,
+    };
+    constexpr VkSubpassDependency dependency{
+        .srcSubpass = VK_SUBPASS_EXTERNAL,
+        .dstSubpass = 0,
+        .srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+        .dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+        .srcAccessMask = 0,
+        .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+        .dependencyFlags = 0,
+    };
+    m_renderpass = m_device.GetLogical().CreateRenderPass(VkRenderPassCreateInfo{
+        .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .attachmentCount = 1,
+        .pAttachments = &attachment,
+        .subpassCount = 1,
+        .pSubpasses = &subpass_description,
+        .dependencyCount = 1,
+        .pDependencies = &dependency,
+    });
+    for (auto& image : m_dynamic_images) {
+        image.framebuffer = CreateWrappedFramebuffer(m_device, m_renderpass, image.image_view, m_extent);
+    }
+}
+
+void SSAA::CreateSampler() {
+    m_sampler = CreateWrappedSampler(m_device);
+}
+
+void SSAA::CreateShaders() {
+    m_vertex_shader = CreateWrappedShaderModule(m_device, SSAA_VERT_SPV);
+    m_fragment_shader = CreateWrappedShaderModule(m_device, SSAA_FRAG_SPV);
+}
+
+void SSAA::CreateDescriptorPool() {
+    // 2 descriptors, 1 descriptor set per image
+    m_descriptor_pool = CreateWrappedDescriptorPool(m_device, 2 * m_image_count, m_image_count);
+}
+
+void SSAA::CreateDescriptorSetLayouts() {
+    m_descriptor_set_layout = CreateWrappedDescriptorSetLayout(m_device, {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER});
+}
+
+void SSAA::CreateDescriptorSets() {
+    VkDescriptorSetLayout layout = *m_descriptor_set_layout;
+    for (auto& images : m_dynamic_images)
+        images.descriptor_sets = CreateWrappedDescriptorSets(m_descriptor_pool, {layout});
+}
+
+void SSAA::CreatePipelineLayouts() {
+    m_pipeline_layout = CreateWrappedPipelineLayout(m_device, m_descriptor_set_layout);
+}
+
+void SSAA::CreatePipelines() {
+    constexpr VkPipelineColorBlendAttachmentState color_blend_attachment_disabled{
+        .blendEnable = VK_FALSE,
+        .srcColorBlendFactor = VK_BLEND_FACTOR_ZERO,
+        .dstColorBlendFactor = VK_BLEND_FACTOR_ZERO,
+        .colorBlendOp = VK_BLEND_OP_ADD,
+        .srcAlphaBlendFactor = VK_BLEND_FACTOR_ZERO,
+        .dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO,
+        .alphaBlendOp = VK_BLEND_OP_ADD,
+        .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT,
+    };
+    const std::array<VkPipelineShaderStageCreateInfo, 2> shader_stages{{
+        {
+            .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
+            .pNext = nullptr,
+            .flags = 0,
+            .stage = VK_SHADER_STAGE_VERTEX_BIT,
+            .module = *m_vertex_shader,
+            .pName = "main",
+            .pSpecializationInfo = nullptr,
+        },
+        {
+            .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
+            .pNext = nullptr,
+            .flags = 0,
+            .stage = VK_SHADER_STAGE_FRAGMENT_BIT,
+            .module = *m_fragment_shader,
+            .pName = "main",
+            .pSpecializationInfo = nullptr,
+        },
+    }};
+    constexpr VkPipelineVertexInputStateCreateInfo vertex_input_ci{
+        .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .vertexBindingDescriptionCount = 0,
+        .pVertexBindingDescriptions = nullptr,
+        .vertexAttributeDescriptionCount = 0,
+        .pVertexAttributeDescriptions = nullptr,
+    };
+    const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci{
+        .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
+        .primitiveRestartEnable = m_device.IsMoltenVK() ? VK_TRUE : VK_FALSE,
+    };
+    constexpr VkPipelineViewportStateCreateInfo viewport_state_ci{
+        .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .viewportCount = 1,
+        .pViewports = nullptr,
+        .scissorCount = 1,
+        .pScissors = nullptr,
+    };
+    constexpr VkPipelineRasterizationStateCreateInfo rasterization_ci{
+        .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .depthClampEnable = VK_FALSE,
+        .rasterizerDiscardEnable = VK_FALSE,
+        .polygonMode = VK_POLYGON_MODE_FILL,
+        .cullMode = VK_CULL_MODE_NONE,
+        .frontFace = VK_FRONT_FACE_CLOCKWISE,
+        .depthBiasEnable = VK_FALSE,
+        .depthBiasConstantFactor = 0.0f,
+        .depthBiasClamp = 0.0f,
+        .depthBiasSlopeFactor = 0.0f,
+        .lineWidth = 1.0f,
+    };
+    const VkPipelineMultisampleStateCreateInfo multisampling_ci{
+        .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .rasterizationSamples = VK_SAMPLE_COUNT_2_BIT,
+        .sampleShadingEnable = Settings::values.sample_shading.GetValue() > 0 ? VK_TRUE : VK_FALSE,
+        .minSampleShading = f32(Settings::values.sample_shading.GetValue()) / 100.0f,
+        .pSampleMask = nullptr,
+        .alphaToCoverageEnable = VK_FALSE,
+        .alphaToOneEnable = VK_FALSE,
+    };
+    const VkPipelineColorBlendStateCreateInfo color_blend_ci{
+        .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .logicOpEnable = VK_FALSE,
+        .logicOp = VK_LOGIC_OP_COPY,
+        .attachmentCount = 1,
+        .pAttachments = &color_blend_attachment_disabled,
+        .blendConstants = {0.0f, 0.0f, 0.0f, 0.0f},
+    };
+    constexpr std::array dynamic_states{
+        VK_DYNAMIC_STATE_VIEWPORT,
+        VK_DYNAMIC_STATE_SCISSOR,
+    };
+    const VkPipelineDynamicStateCreateInfo dynamic_state_ci{
+        .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .dynamicStateCount = u32(dynamic_states.size()),
+        .pDynamicStates = dynamic_states.data(),
+    };
+    m_pipeline = m_device.GetLogical().CreateGraphicsPipeline(VkGraphicsPipelineCreateInfo{
+        .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .stageCount = static_cast<u32>(shader_stages.size()),
+        .pStages = shader_stages.data(),
+        .pVertexInputState = &vertex_input_ci,
+        .pInputAssemblyState = &input_assembly_ci,
+        .pTessellationState = nullptr,
+        .pViewportState = &viewport_state_ci,
+        .pRasterizationState = &rasterization_ci,
+        .pMultisampleState = &multisampling_ci,
+        .pDepthStencilState = nullptr,
+        .pColorBlendState = &color_blend_ci,
+        .pDynamicState = &dynamic_state_ci,
+        .layout = *m_pipeline_layout,
+        .renderPass = *m_renderpass,
+        .subpass = 0,
+        .basePipelineHandle = 0,
+        .basePipelineIndex = 0,
+    });
+}
+
+void SSAA::UpdateDescriptorSets(VkImageView image_view, size_t image_index) {
+    Image& image = m_dynamic_images[image_index];
+    std::vector<VkDescriptorImageInfo> image_infos;
+    std::vector<VkWriteDescriptorSet> updates;
+    image_infos.reserve(2);
+    updates.push_back(CreateWriteDescriptorSet(image_infos, *m_sampler, image_view, image.descriptor_sets[0], 0));
+    updates.push_back(CreateWriteDescriptorSet(image_infos, *m_sampler, image_view, image.descriptor_sets[0], 1));
+    m_device.GetLogical().UpdateDescriptorSets(updates, {});
+}
+
+void SSAA::UploadImages(Scheduler& scheduler) {
+    if (!m_images_ready) {
+        m_images_ready = true;
+        scheduler.Record([&](vk::CommandBuffer cmdbuf) {
+            for (auto& image : m_dynamic_images)
+                ClearColorImage(cmdbuf, *image.image);
+        });
+        scheduler.Finish();
+    }
+}
+
+void SSAA::Draw(Scheduler& scheduler, size_t image_index, VkImage* inout_image, VkImageView* inout_image_view) {
+    const Image& image{m_dynamic_images[image_index]};
+    const VkImage input_image{*inout_image};
+    const VkImage output_image{*image.image};
+    const VkDescriptorSet descriptor_set{image.descriptor_sets[0]};
+    const VkFramebuffer framebuffer{*image.framebuffer};
+    const VkRenderPass renderpass{*m_renderpass};
+    const VkPipeline pipeline{*m_pipeline};
+    const VkPipelineLayout layout{*m_pipeline_layout};
+    const VkExtent2D extent{m_extent};
+
+    UploadImages(scheduler);
+    UpdateDescriptorSets(*inout_image_view, image_index);
+
+    scheduler.RequestOutsideRenderPassOperationContext();
+    scheduler.Record([=](vk::CommandBuffer cmdbuf) {
+        TransitionImageLayout(cmdbuf, input_image, VK_IMAGE_LAYOUT_GENERAL);
+        TransitionImageLayout(cmdbuf, output_image, VK_IMAGE_LAYOUT_GENERAL);
+        BeginRenderPass(cmdbuf, renderpass, framebuffer, extent);
+        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
+        cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set, {});
+        cmdbuf.Draw(3, 1, 0, 0);
+        cmdbuf.EndRenderPass();
+        TransitionImageLayout(cmdbuf, output_image, VK_IMAGE_LAYOUT_GENERAL);
+    });
+
+    *inout_image = *image.image;
+    *inout_image_view = *image.image_view;
+}
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/ssaa.h

@@ -0,0 +1,63 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "video_core/renderer_vulkan/present/anti_alias_pass.h"
+#include "video_core/vulkan_common/vulkan_memory_allocator.h"
+#include "video_core/vulkan_common/vulkan_wrapper.h"
+
+namespace Vulkan {
+
+class Device;
+class Scheduler;
+class StagingBufferPool;
+
+class SSAA final : public AntiAliasPass {
+public:
+    explicit SSAA(const Device& device, MemoryAllocator& allocator, size_t image_count,
+                  VkExtent2D extent);
+    ~SSAA() override;
+
+    void Draw(Scheduler& scheduler, size_t image_index, VkImage* inout_image,
+              VkImageView* inout_image_view) override;
+
+private:
+    void CreateImages();
+    void CreateRenderPasses();
+    void CreateSampler();
+    void CreateShaders();
+    void CreateDescriptorPool();
+    void CreateDescriptorSetLayouts();
+    void CreateDescriptorSets();
+    void CreatePipelineLayouts();
+    void CreatePipelines();
+    void UpdateDescriptorSets(VkImageView image_view, size_t image_index);
+    void UploadImages(Scheduler& scheduler);
+
+    const Device& m_device;
+    MemoryAllocator& m_allocator;
+    const VkExtent2D m_extent;
+    const u32 m_image_count;
+
+    vk::ShaderModule m_vertex_shader{};
+    vk::ShaderModule m_fragment_shader{};
+    vk::DescriptorPool m_descriptor_pool{};
+    vk::DescriptorSetLayout m_descriptor_set_layout{};
+    vk::PipelineLayout m_pipeline_layout{};
+    vk::Pipeline m_pipeline{};
+    vk::RenderPass m_renderpass{};
+
+    struct Image {
+        vk::DescriptorSets descriptor_sets{};
+        vk::Framebuffer framebuffer{};
+        vk::Image image{};
+        vk::ImageView image_view{};
+    };
+    std::vector<Image> m_dynamic_images{};
+    bool m_images_ready{};
+
+    vk::Sampler m_sampler{};
+};
+
+} // namespace Vulkan