vk_rasterizer: flip scissor y on lower left origin mode (#13122)

src/video_core/engines/draw_manager.cpp

@@ -216,14 +216,11 @@ void DrawManager::DrawTexture() {
     const bool lower_left{regs.window_origin.mode !=
                           Maxwell3D::Regs::WindowOrigin::Mode::UpperLeft};
     if (lower_left) {
-        draw_texture_state.dst_y0 -= dst_height;
+        draw_texture_state.dst_y0 =
+            static_cast<f32>(regs.surface_clip.height) - draw_texture_state.dst_y0;
     }
-    draw_texture_state.dst_x1 =
+    draw_texture_state.dst_x1 = draw_texture_state.dst_x0 + dst_width;
-        draw_texture_state.dst_x0 +
+    draw_texture_state.dst_y1 = draw_texture_state.dst_y0 + dst_height;
-        static_cast<f32>(Settings::values.resolution_info.ScaleUp(static_cast<u32>(dst_width)));
-    draw_texture_state.dst_y1 =
-        draw_texture_state.dst_y0 +
-        static_cast<f32>(Settings::values.resolution_info.ScaleUp(static_cast<u32>(dst_height)));
     draw_texture_state.src_x0 = static_cast<float>(regs.draw_texture.src_x0) / 4096.f;
     draw_texture_state.src_y0 = static_cast<float>(regs.draw_texture.src_y0) / 4096.f;
     draw_texture_state.src_x1 =

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -370,27 +370,32 @@ void RasterizerOpenGL::DrawTexture() {
     const auto& sampler = texture_cache.GetGraphicsSampler(draw_texture_state.src_sampler);
     const auto& texture = texture_cache.GetImageView(draw_texture_state.src_texture);
 
+    const auto Scale = [&](auto dim) -> s32 {
+        return Settings::values.resolution_info.ScaleUp(static_cast<s32>(dim));
+    };
+
+    Region2D dst_region = {
+        Offset2D{.x = Scale(draw_texture_state.dst_x0), .y = Scale(draw_texture_state.dst_y0)},
+        Offset2D{.x = Scale(draw_texture_state.dst_x1), .y = Scale(draw_texture_state.dst_y1)}};
+    Region2D src_region = {
+        Offset2D{.x = Scale(draw_texture_state.src_x0), .y = Scale(draw_texture_state.src_y0)},
+        Offset2D{.x = Scale(draw_texture_state.src_x1), .y = Scale(draw_texture_state.src_y1)}};
+    Extent3D src_size = {static_cast<u32>(Scale(texture.size.width)),
+                         static_cast<u32>(Scale(texture.size.height)), texture.size.depth};
+
     if (device.HasDrawTexture()) {
         state_tracker.BindFramebuffer(texture_cache.GetFramebuffer()->Handle());
 
-        glDrawTextureNV(texture.DefaultHandle(), sampler->Handle(), draw_texture_state.dst_x0,
+        glDrawTextureNV(texture.DefaultHandle(), sampler->Handle(),
-                        draw_texture_state.dst_y0, draw_texture_state.dst_x1,
+                        static_cast<f32>(dst_region.start.x), static_cast<f32>(dst_region.start.y),
-                        draw_texture_state.dst_y1, 0,
+                        static_cast<f32>(dst_region.end.x), static_cast<f32>(dst_region.end.y), 0,
                         draw_texture_state.src_x0 / static_cast<float>(texture.size.width),
                         draw_texture_state.src_y0 / static_cast<float>(texture.size.height),
                         draw_texture_state.src_x1 / static_cast<float>(texture.size.width),
                         draw_texture_state.src_y1 / static_cast<float>(texture.size.height));
     } else {
-        Region2D dst_region = {Offset2D{.x = static_cast<s32>(draw_texture_state.dst_x0),
-                                        .y = static_cast<s32>(draw_texture_state.dst_y0)},
-                               Offset2D{.x = static_cast<s32>(draw_texture_state.dst_x1),
-                                        .y = static_cast<s32>(draw_texture_state.dst_y1)}};
-        Region2D src_region = {Offset2D{.x = static_cast<s32>(draw_texture_state.src_x0),
-                                        .y = static_cast<s32>(draw_texture_state.src_y0)},
-                               Offset2D{.x = static_cast<s32>(draw_texture_state.src_x1),
-                                        .y = static_cast<s32>(draw_texture_state.src_y1)}};
         blit_image.BlitColor(texture_cache.GetFramebuffer()->Handle(), texture.DefaultHandle(),
-                             sampler->Handle(), dst_region, src_region, texture.size);
+                             sampler->Handle(), dst_region, src_region, src_size);
         state_tracker.InvalidateState();
     }
 

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -125,11 +125,23 @@ VkRect2D GetScissorState(const Maxwell& regs, size_t index, u32 up_scale = 1, u3
         return value < 0 ? std::min<s32>(converted_value - acumm, -1)
                          : std::max<s32>(converted_value + acumm, 1);
     };
+
+    const bool lower_left = regs.window_origin.mode != Maxwell::WindowOrigin::Mode::UpperLeft;
+    const s32 clip_height = regs.surface_clip.height;
+
+    // Flip coordinates if lower left
+    s32 min_y = lower_left ? (clip_height - src.max_y) : src.min_y.Value();
+    s32 max_y = lower_left ? (clip_height - src.min_y) : src.max_y.Value();
+
+    // Bound to render area
+    min_y = std::max(min_y, 0);
+    max_y = std::max(max_y, 0);
+
     if (src.enable) {
-        scissor.offset.x = scale_up(static_cast<s32>(src.min_x));
+        scissor.offset.x = scale_up(src.min_x);
-        scissor.offset.y = scale_up(static_cast<s32>(src.min_y));
+        scissor.offset.y = scale_up(min_y);
         scissor.extent.width = scale_up(src.max_x - src.min_x);
-        scissor.extent.height = scale_up(src.max_y - src.min_y);
+        scissor.extent.height = scale_up(max_y - min_y);
     } else {
         scissor.offset.x = 0;
         scissor.offset.y = 0;
@@ -308,17 +320,33 @@ void RasterizerVulkan::DrawTexture() {
     const auto& draw_texture_state = maxwell3d->draw_manager->GetDrawTextureState();
     const auto& sampler = texture_cache.GetGraphicsSampler(draw_texture_state.src_sampler);
     const auto& texture = texture_cache.GetImageView(draw_texture_state.src_texture);
-    Region2D dst_region = {Offset2D{.x = static_cast<s32>(draw_texture_state.dst_x0),
+    const auto* framebuffer = texture_cache.GetFramebuffer();
-                                    .y = static_cast<s32>(draw_texture_state.dst_y0)},
+
-                           Offset2D{.x = static_cast<s32>(draw_texture_state.dst_x1),
+    const bool src_rescaling = texture_cache.IsRescaling() && texture.IsRescaled();
-                                    .y = static_cast<s32>(draw_texture_state.dst_y1)}};
+    const bool dst_rescaling = texture_cache.IsRescaling() && framebuffer->IsRescaled();
-    Region2D src_region = {Offset2D{.x = static_cast<s32>(draw_texture_state.src_x0),
+
-                                    .y = static_cast<s32>(draw_texture_state.src_y0)},
+    const auto ScaleSrc = [&](auto dim_f) -> s32 {
-                           Offset2D{.x = static_cast<s32>(draw_texture_state.src_x1),
+        auto dim = static_cast<s32>(dim_f);
-                                    .y = static_cast<s32>(draw_texture_state.src_y1)}};
+        return src_rescaling ? Settings::values.resolution_info.ScaleUp(dim) : dim;
-    blit_image.BlitColor(texture_cache.GetFramebuffer(), texture.RenderTarget(),
+    };
-                         texture.ImageHandle(), sampler->Handle(), dst_region, src_region,
+
-                         texture.size);
+    const auto ScaleDst = [&](auto dim_f) -> s32 {
+        auto dim = static_cast<s32>(dim_f);
+        return dst_rescaling ? Settings::values.resolution_info.ScaleUp(dim) : dim;
+    };
+
+    Region2D dst_region = {Offset2D{.x = ScaleDst(draw_texture_state.dst_x0),
+                                    .y = ScaleDst(draw_texture_state.dst_y0)},
+                           Offset2D{.x = ScaleDst(draw_texture_state.dst_x1),
+                                    .y = ScaleDst(draw_texture_state.dst_y1)}};
+    Region2D src_region = {Offset2D{.x = ScaleSrc(draw_texture_state.src_x0),
+                                    .y = ScaleSrc(draw_texture_state.src_y0)},
+                           Offset2D{.x = ScaleSrc(draw_texture_state.src_x1),
+                                    .y = ScaleSrc(draw_texture_state.src_y1)}};
+    Extent3D src_size = {static_cast<u32>(ScaleSrc(texture.size.width)),
+                         static_cast<u32>(ScaleSrc(texture.size.height)), texture.size.depth};
+    blit_image.BlitColor(framebuffer, texture.RenderTarget(), texture.ImageHandle(),
+                         sampler->Handle(), dst_region, src_region, src_size);
 }
 
 void RasterizerVulkan::Clear(u32 layer_count) {

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -1962,21 +1962,22 @@ Framebuffer::Framebuffer(TextureCacheRuntime& runtime, std::span<ImageView*, NUM
 }
 
 Framebuffer::Framebuffer(TextureCacheRuntime& runtime, ImageView* color_buffer,
-                         ImageView* depth_buffer, VkExtent2D extent, bool is_rescaled)
+                         ImageView* depth_buffer, VkExtent2D extent, bool is_rescaled_)
     : render_area{extent} {
     std::array<ImageView*, NUM_RT> color_buffers{color_buffer};
-    CreateFramebuffer(runtime, color_buffers, depth_buffer, is_rescaled);
+    CreateFramebuffer(runtime, color_buffers, depth_buffer, is_rescaled_);
 }
 
 Framebuffer::~Framebuffer() = default;
 
 void Framebuffer::CreateFramebuffer(TextureCacheRuntime& runtime,
                                     std::span<ImageView*, NUM_RT> color_buffers,
-                                    ImageView* depth_buffer, bool is_rescaled) {
+                                    ImageView* depth_buffer, bool is_rescaled_) {
     boost::container::small_vector<VkImageView, NUM_RT + 1> attachments;
     RenderPassKey renderpass_key{};
     s32 num_layers = 1;
 
+    is_rescaled = is_rescaled_;
     const auto& resolution = runtime.resolution;
 
     u32 width = std::numeric_limits<u32>::max();

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -361,6 +361,10 @@ public:
         return has_stencil;
     }
 
+    [[nodiscard]] bool IsRescaled() const noexcept {
+        return is_rescaled;
+    }
+
 private:
     vk::Framebuffer framebuffer;
     VkRenderPass renderpass{};
@@ -373,6 +377,7 @@ private:
     std::array<size_t, NUM_RT> rt_map{};
     bool has_depth{};
     bool has_stencil{};
+    bool is_rescaled{};
 };
 
 struct TextureCacheParams {