renderer_vulkan: added support for MSAA attachments

src/shader_recompiler/ir/passes/resource_tracking_pass.cpp

@@ -294,15 +294,19 @@ void PatchImageInstruction(IR::Block& block, IR::Inst& inst, Info& info, Descrip
     const IR::Inst* body = inst.Arg(1).InstRecursive();
     const auto [coords, arg] = [&] -> std::pair<IR::Value, IR::Value> {
         switch (image.GetType()) {
-        case AmdGpu::ImageType::Color1D:
+        case AmdGpu::ImageType::Color1D: // x
             return {body->Arg(0), body->Arg(1)};
-        case AmdGpu::ImageType::Color1DArray:
+        case AmdGpu::ImageType::Color1DArray: // x, slice
-        case AmdGpu::ImageType::Color2D:
+            [[fallthrough]];
+        case AmdGpu::ImageType::Color2D: // x, y
             return {ir.CompositeConstruct(body->Arg(0), body->Arg(1)), body->Arg(2)};
-        case AmdGpu::ImageType::Color2DArray:
+        case AmdGpu::ImageType::Color2DArray: // x, y, slice
-        case AmdGpu::ImageType::Color3D:
+            [[fallthrough]];
+        case AmdGpu::ImageType::Color2DMsaa: // x, y, frag
+            [[fallthrough]];
+        case AmdGpu::ImageType::Color3D: // x, y, z
             return {ir.CompositeConstruct(body->Arg(0), body->Arg(1), body->Arg(2)), body->Arg(3)};
-        case AmdGpu::ImageType::Cube:
+        case AmdGpu::ImageType::Cube: // x, y, face
             return {PatchCubeCoord(ir, body->Arg(0), body->Arg(1), body->Arg(2)), body->Arg(3)};
         default:
             UNREACHABLE_MSG("Unknown image type {}", image.GetType());

src/video_core/amdgpu/liverpool.h

@@ -791,6 +791,18 @@ struct Liverpool {
         BitField<1, 1, u32> stencil_clear_enable;
     };
 
+    union AaConfig {
+        BitField<0, 3, u32> msaa_num_samples;
+        BitField<4, 1, u32> aa_mask_centroid_dtmn;
+        BitField<13, 4, u32> max_sample_dst;
+        BitField<20, 3, u32> msaa_exposed_samples;
+        BitField<24, 2, u32> detail_to_exposed_mode;
+
+        u32 NumSamples() const {
+            return 1 << msaa_num_samples;
+        }
+    };
+
     union Regs {
         struct {
             INSERT_PADDING_WORDS(0x2C08);
@@ -858,7 +870,9 @@ struct Liverpool {
             u32 enable_primitive_id;
             INSERT_PADDING_WORDS(0xA2DF - 0xA2A1 - 1);
             PolygonOffset poly_offset;
-            INSERT_PADDING_WORDS(0xA318 - 0xA2DF - 5);
+            INSERT_PADDING_WORDS(0xA2F8 - 0xA2DF - 5);
+            AaConfig aa_config;
+            INSERT_PADDING_WORDS(0xA318 - 0xA2F8 - 1);
             ColorBuffer color_buffers[NumColorBuffers];
             INSERT_PADDING_WORDS(0xC242 - 0xA390);
             PrimitiveType primitive_type;
@@ -1022,6 +1036,7 @@ static_assert(GFX6_3D_REG_INDEX(index_size) == 0xA29D);
 static_assert(GFX6_3D_REG_INDEX(index_buffer_type) == 0xA29F);
 static_assert(GFX6_3D_REG_INDEX(enable_primitive_id) == 0xA2A1);
 static_assert(GFX6_3D_REG_INDEX(poly_offset) == 0xA2DF);
+static_assert(GFX6_3D_REG_INDEX(aa_config) == 0xA2F8);
 static_assert(GFX6_3D_REG_INDEX(color_buffers[0].base_address) == 0xA318);
 static_assert(GFX6_3D_REG_INDEX(color_buffers[0].pitch) == 0xA319);
 static_assert(GFX6_3D_REG_INDEX(color_buffers[0].slice) == 0xA31A);

src/video_core/renderer_vulkan/liverpool_to_vk.cpp

@@ -482,4 +482,17 @@ vk::ClearValue ColorBufferClearValue(const AmdGpu::Liverpool::ColorBuffer& color
     return {.color = color};
 }
 
+vk::SampleCountFlagBits NumSamples(u32 num_samples) {
+    switch (num_samples) {
+    case 1:
+        return vk::SampleCountFlagBits::e1;
+    case 2:
+        return vk::SampleCountFlagBits::e2;
+    case 4:
+        return vk::SampleCountFlagBits::e4;
+    default:
+        UNREACHABLE();
+    }
+}
+
 } // namespace Vulkan::LiverpoolToVK

src/video_core/renderer_vulkan/liverpool_to_vk.h

@@ -48,6 +48,8 @@ vk::Format DepthFormat(Liverpool::DepthBuffer::ZFormat z_format,
 
 vk::ClearValue ColorBufferClearValue(const AmdGpu::Liverpool::ColorBuffer& color_buffer);
 
+vk::SampleCountFlagBits NumSamples(u32 num_samples);
+
 void EmitQuadToTriangleListIndices(u8* out_indices, u32 num_vertices);
 
 } // namespace Vulkan::LiverpoolToVK

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -92,7 +92,7 @@ GraphicsPipeline::GraphicsPipeline(const Instance& instance_, Scheduler& schedul
     };
 
     const vk::PipelineMultisampleStateCreateInfo multisampling = {
-        .rasterizationSamples = vk::SampleCountFlagBits::e1,
+        .rasterizationSamples = LiverpoolToVK::NumSamples(key.num_samples),
         .sampleShadingEnable = false,
     };
 

src/video_core/renderer_vulkan/vk_graphics_pipeline.h

@@ -38,6 +38,7 @@ struct GraphicsPipelineKey {
     float depth_bias_slope_factor;
     float depth_bias_clamp;
     u32 depth_bias_enable;
+    u32 num_samples = 1;
     Liverpool::StencilControl stencil;
     Liverpool::StencilRefMask stencil_ref_front;
     Liverpool::StencilRefMask stencil_ref_back;

src/video_core/renderer_vulkan/vk_instance.cpp

@@ -205,6 +205,7 @@ bool Instance::CreateDevice() {
                 .logicOp = features.logicOp,
                 .samplerAnisotropy = features.samplerAnisotropy,
                 .fragmentStoresAndAtomics = features.fragmentStoresAndAtomics,
+                .shaderStorageImageMultisample = true,
                 .shaderClipDistance = features.shaderClipDistance,
             },
         },

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -114,6 +114,7 @@ void PipelineCache::RefreshGraphicsKey() {
     key.cull_mode = regs.polygon_control.CullingMode();
     key.clip_space = regs.clipper_control.clip_space;
     key.front_face = regs.polygon_control.front_face;
+    key.num_samples = regs.aa_config.NumSamples();
 
     const auto& db = regs.depth_buffer;
     if (key.depth.depth_enable) {

src/video_core/texture_cache/image.cpp

@@ -252,6 +252,7 @@ Image::Image(const Vulkan::Instance& instance_, Vulkan::Scheduler& scheduler_,
         },
         .mipLevels = static_cast<u32>(info.resources.levels),
         .arrayLayers = static_cast<u32>(info.resources.layers),
+        .samples = LiverpoolToVK::NumSamples(info.num_samples),
         .tiling = vk::ImageTiling::eOptimal,
         .usage = usage,
         .initialLayout = vk::ImageLayout::eUndefined,
@@ -267,7 +268,7 @@ Image::Image(const Vulkan::Instance& instance_, Vulkan::Scheduler& scheduler_,
     }
 
     Transit(vk::ImageLayout::eGeneral, vk::AccessFlagBits::eNone);
-}
+} // namespace VideoCore
 
 void Image::Transit(vk::ImageLayout dst_layout, vk::Flags<vk::AccessFlagBits> dst_mask) {
     if (dst_layout == layout && dst_mask == access_mask) {