gl_shader_manager: Avoid using uniform constants with explicit locations

Explicit locations break Intel and AMD's proprietary drivers. Use
glGetUniformLocation and implicit locations instead.

src/common/common_paths.h

@@ -36,6 +36,7 @@
 #define LOAD_DIR "load"
 #define DUMP_DIR "dump"
 #define SHADER_DIR "shader"
+#define RESCALING_DIR "rescaling"
 #define LOG_DIR "log"
 
 // Filenames

src/common/file_util.cpp

@@ -695,6 +695,7 @@ const std::string& GetUserPath(UserPath path, const std::string& new_path) {
         paths.emplace(UserPath::LoadDir, user_path + LOAD_DIR DIR_SEP);
         paths.emplace(UserPath::DumpDir, user_path + DUMP_DIR DIR_SEP);
         paths.emplace(UserPath::ShaderDir, user_path + SHADER_DIR DIR_SEP);
+        paths.emplace(UserPath::RescalingDir, user_path + RESCALING_DIR DIR_SEP);
         paths.emplace(UserPath::SysDataDir, user_path + SYSDATA_DIR DIR_SEP);
         paths.emplace(UserPath::KeysDir, user_path + KEYS_DIR DIR_SEP);
         // TODO: Put the logs in a better location for each OS

src/common/file_util.h

@@ -33,6 +33,7 @@ enum class UserPath {
     LoadDir,
     DumpDir,
     ShaderDir,
+    RescalingDir,
     SysDataDir,
     UserDir,
 };

src/core/settings.cpp

@@ -94,6 +94,7 @@ void LogSettings() {
     LogSetting("Renderer_UseAccurateGpuEmulation", Settings::values.use_accurate_gpu_emulation);
     LogSetting("Renderer_UseAsynchronousGpuEmulation",
                Settings::values.use_asynchronous_gpu_emulation);
+    LogSetting("Renderer_UseResolutionScanner", Settings::values.use_resolution_scanner);
     LogSetting("Audio_OutputEngine", Settings::values.sink_id);
     LogSetting("Audio_EnableAudioStretching", Settings::values.enable_audio_stretching);
     LogSetting("Audio_OutputDevice", Settings::values.audio_device_id);

src/core/settings.h

@@ -423,6 +423,7 @@ struct Values {
     bool use_accurate_gpu_emulation;
     bool use_asynchronous_gpu_emulation;
     bool force_30fps_mode;
+    bool use_resolution_scanner;
 
     float bg_red;
     float bg_green;

src/video_core/CMakeLists.txt

@@ -122,6 +122,8 @@ add_library(video_core STATIC
     shader/track.cpp
     surface.cpp
     surface.h
+    texture_cache/resolution_scaling/database.cpp
+    texture_cache/resolution_scaling/database.h
     texture_cache/surface_base.cpp
     texture_cache/surface_base.h
     texture_cache/surface_params.cpp
@@ -171,7 +173,7 @@ endif()
 create_target_directory_groups(video_core)
 
 target_link_libraries(video_core PUBLIC common core)
-target_link_libraries(video_core PRIVATE glad)
+target_link_libraries(video_core PRIVATE glad json-headers)
 if (ENABLE_VULKAN)
     target_link_libraries(video_core PRIVATE sirit)
 endif()

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -251,7 +251,10 @@ void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {
         if (!gpu.regs.IsShaderConfigEnabled(index)) {
             switch (program) {
             case Maxwell::ShaderProgram::Geometry:
-                shader_program_manager->UseTrivialGeometryShader();
+                shader_program_manager->BindGeometryShader(nullptr);
+                break;
+            case Maxwell::ShaderProgram::Fragment:
+                shader_program_manager->BindFragmentShader(nullptr);
                 break;
             default:
                 break;
@@ -261,14 +264,6 @@ void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {
 
         const std::size_t stage{index == 0 ? 0 : index - 1}; // Stage indices are 0 - 5
 
-        GLShader::MaxwellUniformData ubo{};
-        ubo.SetFromRegs(gpu, stage);
-        const auto [buffer, offset] =
-            buffer_cache.UploadHostMemory(&ubo, sizeof(ubo), device.GetUniformBufferAlignment());
-
-        // Bind the emulation info buffer
-        bind_ubo_pushbuffer.Push(buffer, offset, static_cast<GLsizeiptr>(sizeof(ubo)));
-
         Shader shader{shader_cache.GetStageProgram(program)};
 
         const auto stage_enum = static_cast<Maxwell::ShaderStage>(stage);
@@ -282,13 +277,13 @@ void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {
         switch (program) {
         case Maxwell::ShaderProgram::VertexA:
         case Maxwell::ShaderProgram::VertexB:
-            shader_program_manager->UseProgrammableVertexShader(program_handle);
+            shader_program_manager->BindVertexShader(&program_handle);
             break;
         case Maxwell::ShaderProgram::Geometry:
-            shader_program_manager->UseProgrammableGeometryShader(program_handle);
+            shader_program_manager->BindGeometryShader(&program_handle);
             break;
         case Maxwell::ShaderProgram::Fragment:
-            shader_program_manager->UseProgrammableFragmentShader(program_handle);
+            shader_program_manager->BindFragmentShader(&program_handle);
             break;
         default:
             UNIMPLEMENTED_MSG("Unimplemented shader index={}, enable={}, offset=0x{:08X}", index,
@@ -380,6 +375,7 @@ void RasterizerOpenGL::UpdatePagesCachedCount(VAddr addr, u64 size, int delta) {
 void RasterizerOpenGL::LoadDiskResources(const std::atomic_bool& stop_loading,
                                          const VideoCore::DiskResourceLoadCallback& callback) {
     shader_cache.LoadDiskCache(stop_loading, callback);
+    texture_cache.LoadResources();
 }
 
 void RasterizerOpenGL::ConfigureFramebuffers() {
@@ -426,7 +422,6 @@ void RasterizerOpenGL::ConfigureFramebuffers() {
     texture_cache.GuardRenderTargets(false);
 
     state.draw.draw_framebuffer = framebuffer_cache.GetFramebuffer(fbkey);
-    SyncViewport(state);
 }
 
 void RasterizerOpenGL::ConfigureClearFramebuffer(OpenGLState& current_state, bool using_color_fb,
@@ -552,9 +547,16 @@ void RasterizerOpenGL::Clear() {
 
     ConfigureClearFramebuffer(clear_state, use_color, use_depth, use_stencil);
 
-    SyncViewport(clear_state);
+    bool res_scaling;
+    if (use_color) {
+        res_scaling = texture_cache.IsResolutionScalingEnabledRT(regs.clear_buffers.RT);
+    } else {
+        res_scaling = texture_cache.IsResolutionScalingEnabledDB();
+    }
+
+    SyncViewport(clear_state, res_scaling);
     if (regs.clear_flags.scissor) {
-        SyncScissorTest(clear_state);
+        SyncScissorTest(clear_state, res_scaling);
     }
 
     if (regs.clear_flags.viewport) {
@@ -589,7 +591,6 @@ void RasterizerOpenGL::DrawPrelude() {
     SyncLogicOpState();
     SyncCullMode();
     SyncPrimitiveRestart();
-    SyncScissorTest(state);
     SyncTransformFeedback();
     SyncPointState();
     SyncPolygonOffset();
@@ -605,11 +606,6 @@ void RasterizerOpenGL::DrawPrelude() {
         buffer_size = Common::AlignUp(buffer_size, 4) + CalculateIndexBufferSize();
     }
 
-    // Uniform space for the 5 shader stages
-    buffer_size = Common::AlignUp<std::size_t>(buffer_size, 4) +
-                  (sizeof(GLShader::MaxwellUniformData) + device.GetUniformBufferAlignment()) *
-                      Maxwell::MaxShaderStage;
-
     // Add space for at least 18 constant buffers
     buffer_size += Maxwell::MaxConstBuffers *
                    (Maxwell::MaxConstBufferSize + device.GetUniformBufferAlignment());
@@ -651,6 +647,11 @@ void RasterizerOpenGL::DrawPrelude() {
         gpu.dirty.ResetVertexArrays();
     }
 
+    const bool res_scaling = texture_cache.IsResolutionScalingEnabled();
+    SyncViewport(state, res_scaling);
+    SyncScissorTest(state, res_scaling);
+
+    shader_program_manager->SetConstants(gpu, res_scaling);
     shader_program_manager->ApplyTo(state);
     state.Apply();
 
@@ -773,7 +774,7 @@ void RasterizerOpenGL::DispatchCompute(GPUVAddr code_addr) {
     SetupComputeImages(kernel);
 
     const auto [program, next_bindings] = kernel->GetProgramHandle(variant);
-    state.draw.shader_program = program;
+    state.draw.shader_program = program.handle;
     state.draw.program_pipeline = 0;
 
     const std::size_t buffer_size =
@@ -1072,20 +1073,21 @@ void RasterizerOpenGL::SetupImage(u32 binding, const Tegra::Texture::TICEntry& t
     state.images[binding] = view->GetTexture();
 }
 
-void RasterizerOpenGL::SyncViewport(OpenGLState& current_state) {
+void RasterizerOpenGL::SyncViewport(OpenGLState& current_state, bool rescaling) {
     const auto& regs = system.GPU().Maxwell3D().regs;
     const bool geometry_shaders_enabled =
         regs.IsShaderConfigEnabled(static_cast<size_t>(Maxwell::ShaderProgram::Geometry));
     const std::size_t viewport_count =
         geometry_shaders_enabled ? Tegra::Engines::Maxwell3D::Regs::NumViewports : 1;
+    const float factor = rescaling ? Settings::values.resolution_factor : 1.0f;
     for (std::size_t i = 0; i < viewport_count; i++) {
         auto& viewport = current_state.viewports[i];
         const auto& src = regs.viewports[i];
         const Common::Rectangle<s32> viewport_rect{regs.viewport_transform[i].GetRect()};
-        viewport.x = viewport_rect.left;
-        viewport.y = viewport_rect.bottom;
-        viewport.width = viewport_rect.GetWidth();
-        viewport.height = viewport_rect.GetHeight();
+        viewport.x = static_cast<GLint>(viewport_rect.left * factor);
+        viewport.y = static_cast<GLint>(viewport_rect.bottom * factor);
+        viewport.width = static_cast<GLint>(viewport_rect.GetWidth() * factor);
+        viewport.height = static_cast<GLint>(viewport_rect.GetHeight() * factor);
         viewport.depth_range_far = src.depth_range_far;
         viewport.depth_range_near = src.depth_range_near;
     }
@@ -1296,12 +1298,13 @@ void RasterizerOpenGL::SyncLogicOpState() {
     state.logic_op.operation = MaxwellToGL::LogicOp(regs.logic_op.operation);
 }
 
-void RasterizerOpenGL::SyncScissorTest(OpenGLState& current_state) {
+void RasterizerOpenGL::SyncScissorTest(OpenGLState& current_state, bool rescaling) {
     const auto& regs = system.GPU().Maxwell3D().regs;
     const bool geometry_shaders_enabled =
         regs.IsShaderConfigEnabled(static_cast<size_t>(Maxwell::ShaderProgram::Geometry));
     const std::size_t viewport_count =
         geometry_shaders_enabled ? Tegra::Engines::Maxwell3D::Regs::NumViewports : 1;
+    const float factor = rescaling ? Settings::values.resolution_factor : 1.0f;
     for (std::size_t i = 0; i < viewport_count; i++) {
         const auto& src = regs.scissor_test[i];
         auto& dst = current_state.viewports[i].scissor;
@@ -1311,10 +1314,10 @@ void RasterizerOpenGL::SyncScissorTest(OpenGLState& current_state) {
         }
         const u32 width = src.max_x - src.min_x;
         const u32 height = src.max_y - src.min_y;
-        dst.x = src.min_x;
-        dst.y = src.min_y;
-        dst.width = width;
-        dst.height = height;
+        dst.x = static_cast<u32>(src.min_x * factor);
+        dst.y = static_cast<u32>(src.min_y * factor);
+        dst.width = static_cast<u32>(width * factor);
+        dst.height = static_cast<u32>(height * factor);
     }
 }
 

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -128,7 +128,7 @@ private:
                     const GLShader::ImageEntry& entry);
 
     /// Syncs the viewport and depth range to match the guest state
-    void SyncViewport(OpenGLState& current_state);
+    void SyncViewport(OpenGLState& current_state, bool rescaling);
 
     /// Syncs the clip enabled status to match the guest state
     void SyncClipEnabled(
@@ -162,7 +162,7 @@ private:
     void SyncMultiSampleState();
 
     /// Syncs the scissor test state to match the guest state
-    void SyncScissorTest(OpenGLState& current_state);
+    void SyncScissorTest(OpenGLState& current_state, bool rescaling);
 
     /// Syncs the transform feedback state to match the guest state
     void SyncTransformFeedback();

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -23,9 +23,6 @@ namespace OpenGL {
 
 using VideoCommon::Shader::ProgramCode;
 
-// One UBO is always reserved for emulation values on staged shaders
-constexpr u32 STAGE_RESERVED_UBOS = 1;
-
 struct UnspecializedShader {
     std::string code;
     GLShader::ShaderEntries entries;
@@ -224,10 +221,6 @@ CachedProgram SpecializeShader(const std::string& code, const GLShader::ShaderEn
     }
     source += '\n';
 
-    if (program_type != ProgramType::Compute) {
-        source += fmt::format("#define EMULATION_UBO_BINDING {}\n", base_bindings.cbuf++);
-    }
-
     for (const auto& cbuf : entries.const_buffers) {
         source +=
             fmt::format("#define CBUF_BINDING_{} {}\n", cbuf.GetIndex(), base_bindings.cbuf++);
@@ -273,8 +266,9 @@ CachedProgram SpecializeShader(const std::string& code, const GLShader::ShaderEn
     OGLShader shader;
     shader.Create(source.c_str(), GetShaderType(program_type));
 
-    auto program = std::make_shared<OGLProgram>();
+    auto program = std::make_shared<GLShader::StageProgram>();
     program->Create(true, hint_retrievable, shader.handle);
+    program->SetUniformLocations();
     return program;
 }
 
@@ -348,28 +342,26 @@ Shader CachedShader::CreateKernelFromCache(const ShaderParameters& params,
         new CachedShader(params, ProgramType::Compute, std::move(result)));
 }
 
-std::tuple<GLuint, BaseBindings> CachedShader::GetProgramHandle(const ProgramVariant& variant) {
+std::tuple<GLShader::StageProgram&, BaseBindings> CachedShader::GetProgramHandle(
+    const ProgramVariant& variant) {
     const auto [entry, is_cache_miss] = programs.try_emplace(variant);
-    auto& program = entry->second;
+    auto& stage_program = entry->second;
     if (is_cache_miss) {
-        program = TryLoadProgram(variant);
-        if (!program) {
-            program = SpecializeShader(code, entries, program_type, variant);
+        stage_program = TryLoadProgram(variant);
+        if (!stage_program) {
+            stage_program = SpecializeShader(code, entries, program_type, variant);
             disk_cache.SaveUsage(GetUsage(variant));
         }
 
-        LabelGLObject(GL_PROGRAM, program->handle, cpu_addr);
+        LabelGLObject(GL_PROGRAM, stage_program->handle, cpu_addr);
     }
 
-    auto base_bindings = variant.base_bindings;
+    auto base_bindings{variant.base_bindings};
     base_bindings.cbuf += static_cast<u32>(entries.const_buffers.size());
-    if (program_type != ProgramType::Compute) {
-        base_bindings.cbuf += STAGE_RESERVED_UBOS;
-    }
     base_bindings.gmem += static_cast<u32>(entries.global_memory_entries.size());
     base_bindings.sampler += static_cast<u32>(entries.samplers.size());
 
-    return {program->handle, base_bindings};
+    return {*stage_program, base_bindings};
 }
 
 CachedProgram CachedShader::TryLoadProgram(const ProgramVariant& variant) const {
@@ -516,7 +508,7 @@ CachedProgram ShaderCacheOpenGL::GeneratePrecompiledProgram(
         return {};
     }
 
-    CachedProgram shader = std::make_shared<OGLProgram>();
+    CachedProgram shader = std::make_shared<GLShader::StageProgram>();
     shader->handle = glCreateProgram();
     glProgramParameteri(shader->handle, GL_PROGRAM_SEPARABLE, GL_TRUE);
     glProgramBinary(shader->handle, dump.binary_format, dump.binary.data(),

src/video_core/renderer_opengl/gl_shader_cache.h

@@ -20,6 +20,7 @@
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/gl_shader_decompiler.h"
 #include "video_core/renderer_opengl/gl_shader_disk_cache.h"
+#include "video_core/renderer_opengl/gl_shader_manager.h"
 
 namespace Core {
 class System;
@@ -37,7 +38,7 @@ class RasterizerOpenGL;
 struct UnspecializedShader;
 
 using Shader = std::shared_ptr<CachedShader>;
-using CachedProgram = std::shared_ptr<OGLProgram>;
+using CachedProgram = std::shared_ptr<GLShader::StageProgram>;
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 using PrecompiledPrograms = std::unordered_map<ShaderDiskCacheUsage, CachedProgram>;
 using PrecompiledShaders = std::unordered_map<u64, GLShader::ProgramResult>;
@@ -80,7 +81,8 @@ public:
     }
 
     /// Gets the GL program handle for the shader
-    std::tuple<GLuint, BaseBindings> GetProgramHandle(const ProgramVariant& variant);
+    std::tuple<GLShader::StageProgram&, BaseBindings> GetProgramHandle(
+        const ProgramVariant& variant);
 
 private:
     explicit CachedShader(const ShaderParameters& params, ProgramType program_type,

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -946,9 +946,18 @@ private:
                 return {fmt::format("gl_in[{}].gl_Position{}", Visit(buffer).AsUint(),
                                     GetSwizzle(element)),
                         Type::Float};
-            case ProgramType::Fragment:
-                return {element == 3 ? "1.0f" : ("gl_FragCoord"s + GetSwizzle(element)),
-                        Type::Float};
+            case ProgramType::Fragment: {
+                switch (element) {
+                case 0:
+                    return {"(gl_FragCoord.x / utof(config_pack[3]))", Type::Float};
+                case 1:
+                    return {"(gl_FragCoord.y / utof(config_pack[3]))", Type::Float};
+                case 2:
+                    return {"gl_FragCoord.z", Type::Float};
+                case 3:
+                    return {"1.0f", Type::Float};
+                }
+            }
             default:
                 UNREACHABLE();
             }
@@ -2486,7 +2495,9 @@ std::string GetCommonDeclarations() {
         "    bvec2 is_nan2 = isnan(pair2);\n"
         "    return bvec2(comparison.x || is_nan1.x || is_nan2.x, comparison.y || is_nan1.y || "
         "is_nan2.y);\n"
-        "}}\n\n");
+        "}}\n\n"
+        "uniform uvec4 config_pack; // instance_id, flip_stage, y_direction, padding\n"
+        "uniform vec2 viewport_flip;\n\n");
 }
 
 ProgramResult Decompile(const Device& device, const ShaderIR& ir, ProgramType stage,

src/video_core/renderer_opengl/gl_shader_gen.cpp

@@ -27,14 +27,6 @@ ProgramResult GenerateVertexShader(const Device& device, const ShaderSetup& setu
     std::string out = "// Shader Unique Id: VS" + id + "\n\n";
     out += GetCommonDeclarations();
 
-    out += R"(
-layout (std140, binding = EMULATION_UBO_BINDING) uniform vs_config {
-    vec4 viewport_flip;
-    uvec4 config_pack; // instance_id, flip_stage, y_direction, padding
-};
-
-)";
-
     const ShaderIR program_ir(setup.program.code, PROGRAM_OFFSET, setup.program.size_a, settings);
     const auto stage = setup.IsDualProgram() ? ProgramType::VertexA : ProgramType::VertexB;
     ProgramResult program = Decompile(device, program_ir, stage, "vertex");
@@ -77,14 +69,6 @@ ProgramResult GenerateGeometryShader(const Device& device, const ShaderSetup& se
     std::string out = "// Shader Unique Id: GS" + id + "\n\n";
     out += GetCommonDeclarations();
 
-    out += R"(
-layout (std140, binding = EMULATION_UBO_BINDING) uniform gs_config {
-    vec4 viewport_flip;
-    uvec4 config_pack; // instance_id, flip_stage, y_direction, padding
-};
-
-)";
-
     const ShaderIR program_ir(setup.program.code, PROGRAM_OFFSET, setup.program.size_a, settings);
     ProgramResult program = Decompile(device, program_ir, ProgramType::Geometry, "geometry");
     out += program.first;
@@ -92,7 +76,7 @@ layout (std140, binding = EMULATION_UBO_BINDING) uniform gs_config {
     out += R"(
 void main() {
     execute_geometry();
-};)";
+})";
 
     return {std::move(out), std::move(program.second)};
 }
@@ -113,11 +97,6 @@ layout (location = 5) out vec4 FragColor5;
 layout (location = 6) out vec4 FragColor6;
 layout (location = 7) out vec4 FragColor7;
 
-layout (std140, binding = EMULATION_UBO_BINDING) uniform fs_config {
-    vec4 viewport_flip;
-    uvec4 config_pack; // instance_id, flip_stage, y_direction, padding
-};
-
 )";
 
     const ShaderIR program_ir(setup.program.code, PROGRAM_OFFSET, setup.program.size_a, settings);

src/video_core/renderer_opengl/gl_shader_manager.cpp

@@ -2,13 +2,35 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <array>
 #include "common/common_types.h"
+#include "core/settings.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_opengl/gl_shader_manager.h"
 
 namespace OpenGL::GLShader {
 
-using Tegra::Engines::Maxwell3D;
+using Maxwell = Tegra::Engines::Maxwell3D::Regs;
+
+StageProgram::StageProgram() = default;
+
+StageProgram::~StageProgram() = default;
+
+void StageProgram::SetUniformLocations() {
+    config_pack_location = glGetUniformLocation(handle, "config_pack");
+    viewport_flip_location = glGetUniformLocation(handle, "viewport_flip");
+}
+
+void StageProgram::UpdateConstants() {
+    if (state.config_pack != old_state.config_pack) {
+        glProgramUniform4uiv(handle, config_pack_location, 1, state.config_pack.data());
+        old_state.config_pack = state.config_pack;
+    }
+    if (state.viewport_scale != old_state.viewport_scale) {
+        glProgramUniform2fv(handle, viewport_flip_location, 1, state.viewport_scale.data());
+        old_state.viewport_scale = state.viewport_scale;
+    }
+}
 
 ProgramManager::ProgramManager() {
     pipeline.Create();
@@ -16,12 +38,59 @@ ProgramManager::ProgramManager() {
 
 ProgramManager::~ProgramManager() = default;
 
+void ProgramManager::SetConstants(Tegra::Engines::Maxwell3D& maxwell_3d, bool rescaling) {
+    const auto& regs = maxwell_3d.regs;
+    const auto& state = maxwell_3d.state;
+
+    // TODO(bunnei): Support more than one viewport
+    const GLfloat flip_x = regs.viewport_transform[0].scale_x < 0.0 ? -1.0f : 1.0f;
+    const GLfloat flip_y = regs.viewport_transform[0].scale_y < 0.0 ? -1.0f : 1.0f;
+
+    const GLuint instance_id = state.current_instance;
+
+    // Assign in which stage the position has to be flipped (the last stage before the fragment
+    // shader).
+    const GLuint flip_stage = [&]() {
+        constexpr u32 geometry_index = static_cast<u32>(Maxwell::ShaderProgram::Geometry);
+        if (regs.shader_config[geometry_index].enable) {
+            return geometry_index;
+        } else {
+            return static_cast<u32>(Maxwell::ShaderProgram::VertexB);
+        }
+    }();
+
+    // Y_NEGATE controls what value S2R returns for the Y_DIRECTION system value.
+    const GLfloat y_direction = regs.screen_y_control.y_negate == 0 ? 1.0f : -1.0f;
+
+    const GLfloat rescale_factor = rescaling ? Settings::values.resolution_factor : 1.0f;
+
+    for (const auto stage :
+         {current_state.vertex, current_state.geometry, current_state.fragment}) {
+        if (!stage) {
+            continue;
+        }
+        stage->SetInstanceID(instance_id);
+        stage->SetFlipStage(flip_stage);
+        stage->SetYDirection(y_direction);
+        stage->SetViewportScale(flip_x, flip_y);
+        stage->SetRescalingFactor(rescale_factor);
+        stage->UpdateConstants();
+    }
+}
+
 void ProgramManager::ApplyTo(OpenGLState& state) {
     UpdatePipeline();
     state.draw.shader_program = 0;
     state.draw.program_pipeline = pipeline.handle;
 }
 
+GLuint GetHandle(StageProgram* program) {
+    if (!program) {
+        return 0;
+    }
+    return program->handle;
+}
+
 void ProgramManager::UpdatePipeline() {
     // Avoid updating the pipeline when values have no changed
     if (old_state == current_state) {
@@ -33,34 +102,11 @@ void ProgramManager::UpdatePipeline() {
                                      GL_FRAGMENT_SHADER_BIT};
     glUseProgramStages(pipeline.handle, all_used_stages, 0);
 
-    glUseProgramStages(pipeline.handle, GL_VERTEX_SHADER_BIT, current_state.vertex_shader);
-    glUseProgramStages(pipeline.handle, GL_GEOMETRY_SHADER_BIT, current_state.geometry_shader);
-    glUseProgramStages(pipeline.handle, GL_FRAGMENT_SHADER_BIT, current_state.fragment_shader);
+    glUseProgramStages(pipeline.handle, GL_VERTEX_SHADER_BIT, GetHandle(current_state.vertex));
+    glUseProgramStages(pipeline.handle, GL_GEOMETRY_SHADER_BIT, GetHandle(current_state.geometry));
+    glUseProgramStages(pipeline.handle, GL_FRAGMENT_SHADER_BIT, GetHandle(current_state.fragment));
 
     old_state = current_state;
 }
 
-void MaxwellUniformData::SetFromRegs(const Maxwell3D& maxwell, std::size_t shader_stage) {
-    const auto& regs = maxwell.regs;
-    const auto& state = maxwell.state;
-
-    // TODO(bunnei): Support more than one viewport
-    viewport_flip[0] = regs.viewport_transform[0].scale_x < 0.0 ? -1.0f : 1.0f;
-    viewport_flip[1] = regs.viewport_transform[0].scale_y < 0.0 ? -1.0f : 1.0f;
-
-    instance_id = state.current_instance;
-
-    // Assign in which stage the position has to be flipped
-    // (the last stage before the fragment shader).
-    constexpr u32 geometry_index = static_cast<u32>(Maxwell3D::Regs::ShaderProgram::Geometry);
-    if (maxwell.regs.shader_config[geometry_index].enable) {
-        flip_stage = geometry_index;
-    } else {
-        flip_stage = static_cast<u32>(Maxwell3D::Regs::ShaderProgram::VertexB);
-    }
-
-    // Y_NEGATE controls what value S2R returns for the Y_DIRECTION system value.
-    y_direction = regs.screen_y_control.y_negate == 0 ? 1.f : -1.f;
-}
-
 } // namespace OpenGL::GLShader

src/video_core/renderer_opengl/gl_shader_manager.h

@@ -4,71 +4,108 @@
 
 #pragma once
 
+#include <array>
 #include <cstddef>
+#include <tuple>
 
 #include <glad/glad.h>
 
+#include "common/common_types.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/gl_state.h"
 #include "video_core/renderer_opengl/maxwell_to_gl.h"
 
+namespace Tegra::Engines {
+class Maxwell3D;
+}
+
 namespace OpenGL::GLShader {
 
-/// Uniform structure for the Uniform Buffer Object, all vectors must be 16-byte aligned
-/// @note Always keep a vec4 at the end. The GL spec is not clear whether the alignment at
-///       the end of a uniform block is included in UNIFORM_BLOCK_DATA_SIZE or not.
-///       Not following that rule will cause problems on some AMD drivers.
-struct MaxwellUniformData {
-    void SetFromRegs(const Tegra::Engines::Maxwell3D& maxwell, std::size_t shader_stage);
+class StageProgram final : public OGLProgram {
+public:
+    explicit StageProgram();
+    ~StageProgram();
 
-    alignas(16) GLvec4 viewport_flip;
-    struct alignas(16) {
-        GLuint instance_id;
-        GLuint flip_stage;
-        GLfloat y_direction;
+    void SetUniformLocations();
+
+    void UpdateConstants();
+
+    void SetInstanceID(GLuint instance_id) {
+        state.instance_id = instance_id;
+    }
+
+    void SetFlipStage(GLuint flip_stage) {
+        state.flip_stage = flip_stage;
+    }
+
+    void SetYDirection(GLfloat y_direction) {
+        state.y_direction = y_direction;
+    }
+
+    void SetRescalingFactor(GLfloat rescaling_factor) {
+        state.rescaling_factor = rescaling_factor;
+    }
+
+    void SetViewportScale(GLfloat x, GLfloat y) {
+        state.viewport_scale = {x, y};
+    }
+
+private:
+    struct State {
+        union {
+            std::array<GLuint, 4> config_pack{};
+            struct {
+                GLuint instance_id;
+                GLuint flip_stage;
+                GLfloat y_direction;
+                GLfloat rescaling_factor;
+            };
+        };
+
+        std::array<GLfloat, 2> viewport_scale{};
     };
-};
-static_assert(sizeof(MaxwellUniformData) == 32, "MaxwellUniformData structure size is incorrect");
-static_assert(sizeof(MaxwellUniformData) < 16384,
-              "MaxwellUniformData structure must be less than 16kb as per the OpenGL spec");
 
-class ProgramManager {
+    GLint config_pack_location = -1;
+    GLint viewport_flip_location = -1;
+
+    State state;
+    State old_state;
+};
+
+class ProgramManager final {
 public:
     explicit ProgramManager();
     ~ProgramManager();
 
+    void SetConstants(Tegra::Engines::Maxwell3D& maxwell_3d, bool rescaling);
+
     void ApplyTo(OpenGLState& state);
 
-    void UseProgrammableVertexShader(GLuint program) {
-        current_state.vertex_shader = program;
+    void BindVertexShader(StageProgram* program) {
+        current_state.vertex = program;
     }
 
-    void UseProgrammableGeometryShader(GLuint program) {
-        current_state.geometry_shader = program;
+    void BindGeometryShader(StageProgram* program) {
+        current_state.geometry = program;
     }
 
-    void UseProgrammableFragmentShader(GLuint program) {
-        current_state.fragment_shader = program;
-    }
-
-    void UseTrivialGeometryShader() {
-        current_state.geometry_shader = 0;
+    void BindFragmentShader(StageProgram* program) {
+        current_state.fragment = program;
     }
 
 private:
     struct PipelineState {
         bool operator==(const PipelineState& rhs) const {
-            return vertex_shader == rhs.vertex_shader && fragment_shader == rhs.fragment_shader &&
-                   geometry_shader == rhs.geometry_shader;
+            return vertex == rhs.vertex && fragment == rhs.fragment && geometry == rhs.geometry;
         }
 
         bool operator!=(const PipelineState& rhs) const {
             return !operator==(rhs);
         }
 
-        GLuint vertex_shader{};
-        GLuint fragment_shader{};
-        GLuint geometry_shader{};
+        StageProgram* vertex{};
+        StageProgram* fragment{};
+        StageProgram* geometry{};
     };
 
     void UpdatePipeline();

src/video_core/renderer_opengl/gl_texture_cache.cpp

@@ -199,7 +199,7 @@ void ApplyTextureDefaults(const SurfaceParams& params, GLuint texture) {
 }
 
 OGLTexture CreateTexture(const SurfaceParams& params, GLenum target, GLenum internal_format,
-                         OGLBuffer& texture_buffer) {
+                         OGLBuffer& texture_buffer, u32 resolution_factor) {
     OGLTexture texture;
     texture.Create(target);
 
@@ -214,6 +214,9 @@ OGLTexture CreateTexture(const SurfaceParams& params, GLenum target, GLenum inte
         glTextureBuffer(texture.handle, internal_format, texture_buffer.handle);
         break;
     case SurfaceTarget::Texture2D:
+        glTextureStorage2D(texture.handle, params.emulated_levels, internal_format,
+                           params.width * resolution_factor, params.height * resolution_factor);
+        break;
     case SurfaceTarget::TextureCubemap:
         glTextureStorage2D(texture.handle, params.emulated_levels, internal_format, params.width,
                            params.height);
@@ -242,8 +245,13 @@ CachedSurface::CachedSurface(const GPUVAddr gpu_addr, const SurfaceParams& param
     format = tuple.format;
     type = tuple.type;
     is_compressed = tuple.compressed;
+}
+
+void CachedSurface::Init() {
     target = GetTextureTarget(params.target);
-    texture = CreateTexture(params, target, internal_format, texture_buffer);
+    const u32 resolution_factor =
+        IsRescaled() ? static_cast<u32>(Settings::values.resolution_factor) : 1;
+    texture = CreateTexture(params, target, internal_format, texture_buffer, resolution_factor);
     DecorateSurfaceName();
     main_view = CreateViewInner(
         ViewParams(params.target, 0, params.is_layered ? params.depth : 1, 0, params.num_levels),
@@ -461,7 +469,10 @@ TextureCacheOpenGL::TextureCacheOpenGL(Core::System& system,
 TextureCacheOpenGL::~TextureCacheOpenGL() = default;
 
 Surface TextureCacheOpenGL::CreateSurface(GPUVAddr gpu_addr, const SurfaceParams& params) {
-    return std::make_shared<CachedSurface>(gpu_addr, params);
+    Surface new_surface = std::make_shared<CachedSurface>(gpu_addr, params);
+    SignalCreatedSurface(new_surface);
+    new_surface->Init();
+    return new_surface;
 }
 
 void TextureCacheOpenGL::ImageCopy(Surface& src_surface, Surface& dst_surface,
@@ -472,15 +483,21 @@ void TextureCacheOpenGL::ImageCopy(Surface& src_surface, Surface& dst_surface,
         // A fallback is needed
         return;
     }
+    const bool src_rescaled = src_surface->IsRescaled();
+    const bool dst_rescaled = dst_surface->IsRescaled();
+    if (src_rescaled != dst_rescaled) {
+        LOG_CRITICAL(HW_GPU, "Rescaling Database is incorrectly set! Rescan the database!.");
+    }
+    const u32 factor = src_rescaled ? static_cast<u32>(Settings::values.resolution_factor) : 1U;
     const auto src_handle = src_surface->GetTexture();
     const auto src_target = src_surface->GetTarget();
     const auto dst_handle = dst_surface->GetTexture();
     const auto dst_target = dst_surface->GetTarget();
-    glCopyImageSubData(src_handle, src_target, copy_params.source_level, copy_params.source_x,
-                       copy_params.source_y, copy_params.source_z, dst_handle, dst_target,
-                       copy_params.dest_level, copy_params.dest_x, copy_params.dest_y,
-                       copy_params.dest_z, copy_params.width, copy_params.height,
-                       copy_params.depth);
+    glCopyImageSubData(src_handle, src_target, copy_params.source_level,
+                       copy_params.source_x * factor, copy_params.source_y * factor,
+                       copy_params.source_z, dst_handle, dst_target, copy_params.dest_level,
+                       copy_params.dest_x * factor, copy_params.dest_y * factor, copy_params.dest_z,
+                       copy_params.width * factor, copy_params.height * factor, copy_params.depth);
 }
 
 void TextureCacheOpenGL::ImageBlit(View& src_view, View& dst_view,
@@ -539,8 +556,14 @@ void TextureCacheOpenGL::ImageBlit(View& src_view, View& dst_view,
     const Common::Rectangle<u32>& dst_rect = copy_config.dst_rect;
     const bool is_linear = copy_config.filter == Tegra::Engines::Fermi2D::Filter::Linear;
 
-    glBlitFramebuffer(src_rect.left, src_rect.top, src_rect.right, src_rect.bottom, dst_rect.left,
-                      dst_rect.top, dst_rect.right, dst_rect.bottom, buffers,
+    const bool src_rescaled = src_view->GetParent().IsRescaled();
+    const bool dst_rescaled = dst_view->GetParent().IsRescaled();
+    const u32 factor1 = src_rescaled ? static_cast<u32>(Settings::values.resolution_factor) : 1U;
+    const u32 factor2 = dst_rescaled ? static_cast<u32>(Settings::values.resolution_factor) : 1U;
+
+    glBlitFramebuffer(src_rect.left * factor1, src_rect.top * factor1, src_rect.right * factor1,
+                      src_rect.bottom * factor1, dst_rect.left * factor2, dst_rect.top * factor2,
+                      dst_rect.right * factor2, dst_rect.bottom * factor2, buffers,
                       is_linear && (buffers == GL_COLOR_BUFFER_BIT) ? GL_LINEAR : GL_NEAREST);
 }
 
@@ -553,8 +576,15 @@ void TextureCacheOpenGL::BufferCopy(Surface& src_surface, Surface& dst_surface)
     const auto source_format = GetFormatTuple(src_params.pixel_format, src_params.component_type);
     const auto dest_format = GetFormatTuple(dst_params.pixel_format, dst_params.component_type);
 
-    const std::size_t source_size = src_surface->GetHostSizeInBytes();
-    const std::size_t dest_size = dst_surface->GetHostSizeInBytes();
+    const bool src_rescaled = src_surface->IsRescaled();
+    const bool dst_rescaled = dst_surface->IsRescaled();
+    if (src_rescaled != dst_rescaled) {
+        LOG_CRITICAL(HW_GPU, "Rescaling Database is incorrectly set! Rescan the database!.");
+    }
+    const u32 factor = src_rescaled ? static_cast<u32>(Settings::values.resolution_factor) : 1U;
+
+    const std::size_t source_size = src_surface->GetHostSizeInBytes() * factor * factor;
+    const std::size_t dest_size = dst_surface->GetHostSizeInBytes() * factor * factor;
 
     const std::size_t buffer_size = std::max(source_size, dest_size);
 
@@ -573,8 +603,8 @@ void TextureCacheOpenGL::BufferCopy(Surface& src_surface, Surface& dst_surface)
 
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, copy_pbo_handle);
 
-    const GLsizei width = static_cast<GLsizei>(dst_params.width);
-    const GLsizei height = static_cast<GLsizei>(dst_params.height);
+    const GLsizei width = static_cast<GLsizei>(dst_params.width * factor);
+    const GLsizei height = static_cast<GLsizei>(dst_params.height * factor);
     const GLsizei depth = static_cast<GLsizei>(dst_params.depth);
     if (dest_format.compressed) {
         LOG_CRITICAL(HW_GPU, "Compressed buffer copy is unimplemented!");

src/video_core/renderer_opengl/gl_texture_cache.h

@@ -39,6 +39,8 @@ public:
     explicit CachedSurface(GPUVAddr gpu_addr, const SurfaceParams& params);
     ~CachedSurface();
 
+    void Init();
+
     void UploadTexture(const std::vector<u8>& staging_buffer) override;
     void DownloadTexture(std::vector<u8>& staging_buffer) override;
 
@@ -96,6 +98,10 @@ public:
         return texture_view.handle;
     }
 
+    const CachedSurface& GetParent() const {
+        return surface;
+    }
+
     const SurfaceParams& GetSurfaceParams() const {
         return surface.GetSurfaceParams();
     }

src/video_core/texture_cache/resolution_scaling/database.cpp

@@ -0,0 +1,121 @@
+// Copyright 2019 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include <fstream>
+#include <fmt/format.h>
+#include <json.hpp>
+
+#include "common/assert.h"
+#include "common/common_paths.h"
+#include "common/common_types.h"
+#include "common/file_util.h"
+#include "core/core.h"
+#include "core/hle/kernel/process.h"
+#include "video_core/texture_cache/resolution_scaling/database.h"
+
+namespace VideoCommon::Resolution {
+
+using namespace nlohmann;
+
+std::string GetBaseDir() {
+    return FileUtil::GetUserPath(FileUtil::UserPath::RescalingDir);
+}
+
+ScalingDatabase::ScalingDatabase(Core::System& system) : system{system} {}
+
+ScalingDatabase::~ScalingDatabase() {
+    SaveDatabase();
+}
+
+void ScalingDatabase::Init() {
+    title_id = system.CurrentProcess()->GetTitleID();
+    LoadDatabase();
+    initialized = true;
+}
+
+void ScalingDatabase::LoadDatabase() {
+    const std::string path = GetProfilePath();
+    const bool exists = FileUtil::Exists(path);
+    if (!exists) {
+        return;
+    }
+    std::ifstream file;
+    OpenFStream(file, path, std::ios_base::in);
+    json in;
+    file >> in;
+    u32 version = in["version"].get<u32>();
+    if (version != DBVersion) {
+        return;
+    }
+    for (const auto& entry : in["entries"]) {
+        ResolutionKey key{};
+        key.format = static_cast<PixelFormat>(entry["format"].get<u32>());
+        key.width = entry["width"].get<u32>();
+        key.height = entry["height"].get<u32>();
+        database.insert(key);
+    }
+    for (const auto& entry : in["blacklist"]) {
+        ResolutionKey key{};
+        key.format = static_cast<PixelFormat>(entry["format"].get<u32>());
+        key.width = entry["width"].get<u32>();
+        key.height = entry["height"].get<u32>();
+        blacklist.insert(key);
+    }
+}
+
+void ScalingDatabase::SaveDatabase() {
+    const std::string dir = GetBaseDir();
+    if (!FileUtil::CreateDir(dir)) {
+        LOG_ERROR(HW_GPU, "Failed to create directory={}", dir);
+        return;
+    }
+    json out;
+    out.emplace("version", DBVersion);
+    auto entries = json::array();
+    for (const auto& key : database) {
+        entries.push_back({
+            {"format", static_cast<u32>(key.format)},
+            {"width", key.width},
+            {"height", key.height},
+        });
+    }
+    out.emplace("entries", std::move(entries));
+    auto blacklist_entries = json::array();
+    for (const auto& key : blacklist) {
+        blacklist_entries.push_back({
+            {"format", static_cast<u32>(key.format)},
+            {"width", key.width},
+            {"height", key.height},
+        });
+    }
+    out.emplace("blacklist", std::move(blacklist_entries));
+    const std::string path = GetProfilePath();
+    std::ofstream file;
+    OpenFStream(file, path, std::ios_base::out);
+    file << std::setw(4) << out << std::endl;
+}
+
+void ScalingDatabase::Register(PixelFormat format, u32 width, u32 height) {
+    const ResolutionKey key{format, width, height};
+    if (blacklist.count(key) == 0) {
+        database.insert(key);
+    }
+}
+
+void ScalingDatabase::Unregister(PixelFormat format, u32 width, u32 height) {
+    const ResolutionKey key{format, width, height};
+    database.erase(key);
+    blacklist.insert(key);
+}
+
+std::string ScalingDatabase::GetTitleID() const {
+    return fmt::format("{:016X}", title_id);
+}
+
+std::string ScalingDatabase::GetProfilePath() const {
+    return FileUtil::SanitizePath(GetBaseDir() + DIR_SEP_CHR + GetTitleID() + ".json");
+}
+
+} // namespace VideoCommon::Resolution

src/video_core/texture_cache/resolution_scaling/database.h

@@ -0,0 +1,88 @@
+// Copyright 2019 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <unordered_set>
+#include "video_core/surface.h"
+
+namespace Core {
+class System;
+}
+
+namespace VideoCommon::Resolution {
+
+using VideoCore::Surface::PixelFormat;
+
+struct ResolutionKey {
+    PixelFormat format;
+    u32 width;
+    u32 height;
+    std::size_t Hash() const {
+        const std::size_t comp1 = static_cast<std::size_t>(format) << 44;
+        const std::size_t comp2 = static_cast<std::size_t>(height) << 24;
+        const std::size_t comp3 = static_cast<std::size_t>(width);
+        return comp1 | comp2 | comp3;
+    }
+
+    bool operator==(const ResolutionKey& ks) const {
+        return std::tie(format, width, height) == std::tie(ks.format, ks.width, ks.height);
+    }
+
+    bool operator!=(const ResolutionKey& ks) const {
+        return !(*this == ks);
+    }
+};
+
+} // namespace VideoCommon::Resolution
+
+namespace std {
+
+template <>
+struct hash<VideoCommon::Resolution::ResolutionKey> {
+    std::size_t operator()(const VideoCommon::Resolution::ResolutionKey& k) const {
+        return k.Hash();
+    }
+};
+
+} // namespace std
+
+namespace VideoCommon::Resolution {
+
+class ScalingDatabase {
+public:
+    explicit ScalingDatabase(Core::System& system);
+    ~ScalingDatabase();
+
+    void SaveDatabase();
+    void LoadDatabase();
+    void Init();
+
+    bool IsInDatabase(const PixelFormat format, const u32 width, const u32 height) const {
+        const ResolutionKey key{format, width, height};
+        return database.count(key) > 0;
+    }
+
+    bool IsBlacklisted(const PixelFormat format, const u32 width, const u32 height) const {
+        const ResolutionKey key{format, width, height};
+        return blacklist.count(key) > 0;
+    }
+
+    void Register(const PixelFormat format, const u32 width, const u32 height);
+    void Unregister(const PixelFormat format, const u32 width, const u32 height);
+
+    std::string GetTitleID() const;
+    std::string GetProfilePath() const;
+
+private:
+    std::unordered_set<ResolutionKey> database{};
+    std::unordered_set<ResolutionKey> blacklist{};
+    bool initialized{};
+    u64 title_id{};
+    Core::System& system;
+
+    static constexpr u32 DBVersion = 1;
+};
+
+} // namespace VideoCommon::Resolution

src/video_core/texture_cache/surface_base.h

@@ -205,6 +205,10 @@ public:
         index = index_;
     }
 
+    void MarkAsRescaled(const bool is_rescaled) {
+        this->is_rescaled = is_rescaled;
+    }
+
     void MarkAsPicked(bool is_picked_) {
         is_picked = is_picked_;
     }
@@ -226,6 +230,10 @@ public:
         return index;
     }
 
+    bool IsRescaled() const {
+        return is_rescaled;
+    }
+
     bool IsRegistered() const {
         return is_registered;
     }
@@ -318,6 +326,7 @@ private:
     bool is_target{};
     bool is_registered{};
     bool is_picked{};
+    bool is_rescaled{};
     u32 index{NO_RT};
     u64 modification_tick{};
 };

src/video_core/texture_cache/texture_cache.h

@@ -12,6 +12,7 @@
 #include <tuple>
 #include <unordered_map>
 #include <vector>
+#include <fmt/format.h>
 
 #include <boost/icl/interval_map.hpp>
 #include <boost/range/iterator_range.hpp>
@@ -29,6 +30,7 @@
 #include "video_core/rasterizer_interface.h"
 #include "video_core/surface.h"
 #include "video_core/texture_cache/copy_params.h"
+#include "video_core/texture_cache/resolution_scaling/database.h"
 #include "video_core/texture_cache/surface_base.h"
 #include "video_core/texture_cache/surface_params.h"
 #include "video_core/texture_cache/surface_view.h"
@@ -53,15 +55,27 @@ class TextureCache {
     using IntervalMap = boost::icl::interval_map<CacheAddr, std::set<TSurface>>;
     using IntervalType = typename IntervalMap::interval_type;
 
+private:
+    enum class UnregisterReason : u32 {
+        Invalidated,
+        Recycled,
+        Rebuilt,
+        Restructured,
+    };
+
 public:
     void InvalidateRegion(CacheAddr addr, std::size_t size) {
         std::lock_guard lock{mutex};
 
         for (const auto& surface : GetSurfacesInRegion(addr, size)) {
-            Unregister(surface);
+            Unregister(surface, UnregisterReason::Invalidated);
         }
     }
 
+    void LoadResources() {
+        scaling_database.Init();
+    }
+
     /***
      * `Guard` guarantees that rendertargets don't unregister themselves if the
      * collide. Protection is currently only done on 3D slices.
@@ -151,8 +165,12 @@ public:
             depth_buffer.target->MarkAsRenderTarget(false, NO_RT);
         depth_buffer.target = surface_view.first;
         depth_buffer.view = surface_view.second;
-        if (depth_buffer.target)
+        if (depth_buffer.target) {
             depth_buffer.target->MarkAsRenderTarget(true, DEPTH_RT);
+            if (IsResolutionScannerEnabled()) {
+                MarkScanner(depth_buffer.target);
+            }
+        }
         return surface_view.second;
     }
 
@@ -185,8 +203,12 @@ public:
             render_targets[index].target->MarkAsRenderTarget(false, NO_RT);
         render_targets[index].target = surface_view.first;
         render_targets[index].view = surface_view.second;
-        if (render_targets[index].target)
+        if (render_targets[index].target) {
             render_targets[index].target->MarkAsRenderTarget(true, static_cast<u32>(index));
+            if (IsResolutionScannerEnabled()) {
+                MarkScanner(render_targets[index].target);
+            }
+        }
         return surface_view.second;
     }
 
@@ -231,6 +253,12 @@ public:
         DeduceBestBlit(src_params, dst_params, src_gpu_addr, dst_gpu_addr);
         std::pair<TSurface, TView> dst_surface = GetSurface(dst_gpu_addr, dst_params, true, false);
         std::pair<TSurface, TView> src_surface = GetSurface(src_gpu_addr, src_params, true, false);
+        if (IsResolutionScannerEnabled()) {
+            bool is_candidate = IsInRSDatabase(src_surface.first);
+            if (is_candidate) {
+                MarkScanner(dst_surface.first);
+            }
+        }
         ImageBlit(src_surface.second, dst_surface.second, copy_config);
         dst_surface.first->MarkAsModified(true, Tick());
     }
@@ -254,13 +282,46 @@ public:
         return ++ticks;
     }
 
+    bool IsResolutionScalingEnabled() {
+        if (IsResolutionScannerEnabled()) {
+            return CheckBlackListMatch();
+        }
+        if (!EnabledRescaling()) {
+            return false;
+        }
+        return CheckResolutionScalingEnabled();
+    }
+
+    bool IsResolutionScalingEnabledRT(const std::size_t index) {
+        if (!EnabledRescaling()) {
+            return false;
+        }
+        if (render_targets[index].target) {
+            return render_targets[index].target->IsRescaled();
+        }
+        return false;
+    }
+
+    bool IsResolutionScalingEnabledDB() {
+        if (!EnabledRescaling()) {
+            return false;
+        }
+        if (depth_buffer.target) {
+            return depth_buffer.target->IsRescaled();
+        }
+        return false;
+    }
+
 protected:
     TextureCache(Core::System& system, VideoCore::RasterizerInterface& rasterizer)
-        : system{system}, rasterizer{rasterizer} {
+        : system{system}, rasterizer{rasterizer}, scaling_database{system} {
         for (std::size_t i = 0; i < Tegra::Engines::Maxwell3D::Regs::NumRenderTargets; i++) {
             SetEmptyColorBuffer(i);
         }
 
+        enable_resolution_scaling =
+            Settings::values.resolution_factor != 1.0f && !Settings::values.use_resolution_scanner;
+
         SetEmptyDepthBuffer();
         staging_cache.SetSize(2);
 
@@ -321,13 +382,19 @@ protected:
         rasterizer.UpdatePagesCachedCount(*cpu_addr, size, 1);
     }
 
-    void Unregister(TSurface surface) {
+    void Unregister(TSurface surface, UnregisterReason reason) {
         if (guard_render_targets && surface->IsProtected()) {
             return;
         }
         if (!guard_render_targets && surface->IsRenderTarget()) {
             ManageRenderTargetUnregister(surface);
         }
+
+        if (IsResolutionScannerEnabled()) {
+            if (reason == UnregisterReason::Restructured) {
+                UnmarkScanner(surface);
+            }
+        }
         const std::size_t size = surface->GetSizeInBytes();
         const VAddr cpu_addr = surface->GetCpuAddr();
         rasterizer.UpdatePagesCachedCount(cpu_addr, size, -1);
@@ -353,6 +420,13 @@ protected:
         return GetSurface(gpu_addr, params, true, false);
     }
 
+    // Must be called by child's create surface
+    void SignalCreatedSurface(TSurface& new_surface) {
+        if (EnabledRescaling() && IsInRSDatabase(new_surface)) {
+            new_surface->MarkAsRescaled(true);
+        }
+    }
+
     Core::System& system;
 
 private:
@@ -436,7 +510,7 @@ private:
                                               const MatchTopologyResult untopological) {
         const bool do_load = preserve_contents && Settings::values.use_accurate_gpu_emulation;
         for (auto& surface : overlaps) {
-            Unregister(surface);
+            Unregister(surface, UnregisterReason::Recycled);
         }
         switch (PickStrategy(overlaps, params, gpu_addr, untopological)) {
         case RecycleStrategy::Ignore: {
@@ -495,7 +569,22 @@ private:
                 ImageCopy(current_surface, new_surface, brick);
             }
         }
-        Unregister(current_surface);
+        if (IsResolutionScannerEnabled()) {
+            if (IsInRSDatabase(current_surface)) {
+                if (IsRSBlacklisted(new_surface)) {
+                    UnmarkScanner(current_surface);
+                } else {
+                    MarkScanner(new_surface);
+                }
+            } else if (IsInRSDatabase(new_surface)) {
+                if (IsRSBlacklisted(current_surface)) {
+                    UnmarkScanner(new_surface);
+                } else {
+                    MarkScanner(current_surface);
+                }
+            }
+        }
+        Unregister(current_surface, UnregisterReason::Rebuilt);
         Register(new_surface);
         new_surface->MarkAsModified(current_surface->IsModified(), Tick());
         return {new_surface, new_surface->GetMainView()};
@@ -576,7 +665,7 @@ private:
             return {};
         }
         for (auto surface : overlaps) {
-            Unregister(surface);
+            Unregister(surface, UnregisterReason::Restructured);
         }
         new_surface->MarkAsModified(modified, Tick());
         Register(new_surface);
@@ -843,7 +932,30 @@ private:
         return {new_surface, new_surface->GetMainView()};
     }
 
-    void LoadSurface(const TSurface& surface) {
+    void LoadSurfaceRescaled(TSurface& surface) {
+        const auto& params = surface->GetSurfaceParams();
+        enable_resolution_scaling = false;
+        TSurface proxy = CreateSurface(surface->GetGpuAddr(), params);
+        enable_resolution_scaling = true;
+        staging_cache.GetBuffer(0).resize(proxy->GetHostSizeInBytes());
+        proxy->LoadBuffer(system.GPU().MemoryManager(), staging_cache);
+        proxy->UploadTexture(staging_cache.GetBuffer(0));
+        Tegra::Engines::Fermi2D::Config copy_config;
+        const Common::Rectangle<u32> rect{0, 0, params.width, params.height};
+        copy_config.operation = Tegra::Engines::Fermi2D::Operation::SrcCopy;
+        copy_config.filter = Tegra::Engines::Fermi2D::Filter::Linear;
+        copy_config.src_rect = rect;
+        copy_config.dst_rect = rect;
+        TView src_view = proxy->GetMainView();
+        TView dst_view = surface->GetMainView();
+        ImageBlit(src_view, dst_view, copy_config);
+    }
+
+    void LoadSurface(TSurface& surface) {
+        if (surface->IsRescaled()) {
+            LoadSurfaceRescaled(surface);
+            return;
+        }
         staging_cache.GetBuffer(0).resize(surface->GetHostSizeInBytes());
         surface->LoadBuffer(system.GPU().MemoryManager(), staging_cache);
         surface->UploadTexture(staging_cache.GetBuffer(0));
@@ -854,6 +966,9 @@ private:
         if (!surface->IsModified()) {
             return;
         }
+        if (IsResolutionScannerEnabled()) {
+            UnmarkScanner(surface);
+        }
         staging_cache.GetBuffer(0).resize(surface->GetHostSizeInBytes());
         surface->DownloadTexture(staging_cache.GetBuffer(0));
         surface->FlushBuffer(system.GPU().MemoryManager(), staging_cache);
@@ -924,6 +1039,115 @@ private:
         return {};
     }
 
+    bool EnabledRescaling() const {
+        return enable_resolution_scaling;
+    }
+
+    bool IsResolutionScannerEnabled() const {
+        return Settings::values.use_resolution_scanner;
+    }
+
+    void UnmarkScanner(const TSurface& surface) {
+        const auto params = surface->GetSurfaceParams();
+        scaling_database.Unregister(params.pixel_format, params.width, params.height);
+    }
+
+    void MarkScanner(const TSurface& surface) {
+        const auto params = surface->GetSurfaceParams();
+        if (params.target != SurfaceTarget::Texture2D || params.num_levels > 1 ||
+            params.IsCompressed() || params.block_depth > 1) {
+            return;
+        }
+        scaling_database.Register(params.pixel_format, params.width, params.height);
+    }
+
+    bool IsRSBlacklisted(const TSurface& surface) const {
+        const auto params = surface->GetSurfaceParams();
+        return scaling_database.IsBlacklisted(params.pixel_format, params.width, params.height);
+    }
+
+    bool IsInRSDatabase(const TSurface& surface) const {
+        const auto& params = surface->GetSurfaceParams();
+        return scaling_database.IsInDatabase(params.pixel_format, params.width, params.height);
+    }
+
+    bool CheckBlackListMatch() {
+        u32 enabled_targets = 0;
+        u32 black_listed = 0;
+        bool black_list = false;
+        for (const auto& target : render_targets) {
+            if (target.target) {
+                enabled_targets++;
+                if (IsRSBlacklisted(target.target)) {
+                    black_list = true;
+                    black_listed++;
+                }
+            }
+        }
+        if (depth_buffer.target) {
+            enabled_targets++;
+            if (IsRSBlacklisted(depth_buffer.target)) {
+                black_list = true;
+                black_listed++;
+            }
+        }
+        if (black_list) {
+            if (black_listed != enabled_targets) {
+                std::string blacklist_msg{};
+                for (const auto& target : render_targets) {
+                    if (target.target) {
+                        UnmarkScanner(target.target);
+                        const auto& params = target.target->GetSurfaceParams();
+                        blacklist_msg += fmt::format("Format:{}, Height:{}, Width:{}\n",
+                                                     static_cast<u32>(params.pixel_format),
+                                                     params.height, params.width);
+                    }
+                }
+                if (depth_buffer.target) {
+                    UnmarkScanner(depth_buffer.target);
+                    const auto& params = depth_buffer.target->GetSurfaceParams();
+                    blacklist_msg += fmt::format("Format:{}, Height:{}, Width:{}\n",
+                                                 static_cast<u32>(params.pixel_format),
+                                                 params.height, params.width);
+                }
+                LOG_CRITICAL(HW_GPU, "Scan detected a conflict:\n{}\nBlacklisting all",
+                             blacklist_msg);
+            }
+        }
+        return false;
+    }
+
+    bool CheckResolutionScalingEnabled() {
+        u32 enabled_targets = 0;
+        u32 rescaled_targets = 0;
+        bool rescaling = false;
+        for (const auto& target : render_targets) {
+            if (target.target) {
+                enabled_targets++;
+                if (target.target->IsRescaled()) {
+                    rescaling = true;
+                    rescaled_targets++;
+                }
+            }
+        }
+        if (depth_buffer.target) {
+            enabled_targets++;
+            if (depth_buffer.target->IsRescaled()) {
+                rescaling = true;
+                rescaled_targets++;
+            }
+        }
+        if (rescaling) {
+            if (rescaled_targets != enabled_targets) {
+                LOG_CRITICAL(HW_GPU,
+                             "Rescaling Database is incorrectly set! Rescan the database!.");
+                return false;
+            }
+            return true;
+        }
+        return false;
+    }
+
     constexpr PixelFormat GetSiblingFormat(PixelFormat format) const {
         return siblings_table[static_cast<std::size_t>(format)];
     }
@@ -940,6 +1164,7 @@ private:
     // Guards the cache for protection conflicts.
     bool guard_render_targets{};
     bool guard_samplers{};
+    bool enable_resolution_scaling{};
 
     // The siblings table is for formats that can inter exchange with one another
     // without causing issues. This is only valid when a conflict occurs on a non
@@ -972,6 +1197,8 @@ private:
 
     StagingCache staging_cache;
     std::recursive_mutex mutex;
+
+    Resolution::ScalingDatabase scaling_database;
 };
 
 } // namespace VideoCommon

src/yuzu/configuration/config.cpp

@@ -624,6 +624,8 @@ void Config::ReadRendererValues() {
         ReadSetting(QStringLiteral("use_accurate_gpu_emulation"), false).toBool();
     Settings::values.use_asynchronous_gpu_emulation =
         ReadSetting(QStringLiteral("use_asynchronous_gpu_emulation"), false).toBool();
+    Settings::values.use_resolution_scanner =
+        ReadSetting(QStringLiteral("use_resolution_scanner"), false).toBool();
     Settings::values.force_30fps_mode =
         ReadSetting(QStringLiteral("force_30fps_mode"), false).toBool();
 
@@ -1047,6 +1049,8 @@ void Config::SaveRendererValues() {
                  Settings::values.use_accurate_gpu_emulation, false);
     WriteSetting(QStringLiteral("use_asynchronous_gpu_emulation"),
                  Settings::values.use_asynchronous_gpu_emulation, false);
+    WriteSetting(QStringLiteral("use_resolution_scanner"), Settings::values.use_resolution_scanner,
+                 false);
     WriteSetting(QStringLiteral("force_30fps_mode"), Settings::values.force_30fps_mode, false);
 
     // Cast to double because Qt's written float values are not human-readable

src/yuzu/configuration/configure_graphics.cpp

@@ -10,7 +10,7 @@
 
 namespace {
 enum class Resolution : int {
-    Auto,
+    Scanner,
     Scale1x,
     Scale2x,
     Scale3x,
@@ -19,8 +19,8 @@ enum class Resolution : int {
 
 float ToResolutionFactor(Resolution option) {
     switch (option) {
-    case Resolution::Auto:
-        return 0.f;
+    case Resolution::Scanner:
+        return 1.f;
     case Resolution::Scale1x:
         return 1.f;
     case Resolution::Scale2x:
@@ -30,12 +30,12 @@ float ToResolutionFactor(Resolution option) {
     case Resolution::Scale4x:
         return 4.f;
     }
-    return 0.f;
+    return 1.f;
 }
 
-Resolution FromResolutionFactor(float factor) {
-    if (factor == 0.f) {
-        return Resolution::Auto;
+Resolution FromResolutionFactor(float factor, bool scanner_on) {
+    if (scanner_on) {
+        return Resolution::Scanner;
     } else if (factor == 1.f) {
         return Resolution::Scale1x;
     } else if (factor == 2.f) {
@@ -45,7 +45,7 @@ Resolution FromResolutionFactor(float factor) {
     } else if (factor == 4.f) {
         return Resolution::Scale4x;
     }
-    return Resolution::Auto;
+    return Resolution::Scale1x;
 }
 } // Anonymous namespace
 
@@ -69,8 +69,9 @@ ConfigureGraphics::~ConfigureGraphics() = default;
 void ConfigureGraphics::SetConfiguration() {
     const bool runtime_lock = !Core::System::GetInstance().IsPoweredOn();
 
-    ui->resolution_factor_combobox->setCurrentIndex(
-        static_cast<int>(FromResolutionFactor(Settings::values.resolution_factor)));
+    ui->resolution_factor_combobox->setEnabled(runtime_lock);
+    ui->resolution_factor_combobox->setCurrentIndex(static_cast<int>(FromResolutionFactor(
+        Settings::values.resolution_factor, Settings::values.use_resolution_scanner)));
     ui->use_disk_shader_cache->setEnabled(runtime_lock);
     ui->use_disk_shader_cache->setChecked(Settings::values.use_disk_shader_cache);
     ui->use_accurate_gpu_emulation->setChecked(Settings::values.use_accurate_gpu_emulation);
@@ -83,12 +84,13 @@ void ConfigureGraphics::SetConfiguration() {
 }
 
 void ConfigureGraphics::ApplyConfiguration() {
-    Settings::values.resolution_factor =
-        ToResolutionFactor(static_cast<Resolution>(ui->resolution_factor_combobox->currentIndex()));
+    const auto resolution = static_cast<Resolution>(ui->resolution_factor_combobox->currentIndex());
+    Settings::values.resolution_factor = ToResolutionFactor(resolution);
     Settings::values.use_disk_shader_cache = ui->use_disk_shader_cache->isChecked();
     Settings::values.use_accurate_gpu_emulation = ui->use_accurate_gpu_emulation->isChecked();
     Settings::values.use_asynchronous_gpu_emulation =
         ui->use_asynchronous_gpu_emulation->isChecked();
+    Settings::values.use_resolution_scanner = resolution == Resolution::Scanner;
     Settings::values.force_30fps_mode = ui->force_30fps_mode->isChecked();
     Settings::values.bg_red = static_cast<float>(bg_color.redF());
     Settings::values.bg_green = static_cast<float>(bg_color.greenF());

src/yuzu/configuration/configure_graphics.ui

@@ -63,27 +63,27 @@
            <widget class="QComboBox" name="resolution_factor_combobox">
             <item>
              <property name="text">
-              <string>Auto (Window Size)</string>
+              <string>Profile Scanner (Native)</string>
              </property>
             </item>
             <item>
              <property name="text">
-              <string>Native (1280x720)</string>
+              <string>Native (1280x720/1920x1080)</string>
              </property>
             </item>
             <item>
              <property name="text">
-              <string>2x Native (2560x1440)</string>
+              <string>2x Native (2560x1440/3840x2160)</string>
              </property>
             </item>
             <item>
              <property name="text">
-              <string>3x Native (3840x2160)</string>
+              <string>3x Native (3840x2160/5760x3240)</string>
              </property>
             </item>
             <item>
              <property name="text">
-              <string>4x Native (5120x2880)</string>
+              <string>4x Native (5120x2880/7680x4320)</string>
              </property>
             </item>
            </widget>

src/yuzu/game_list.cpp

@@ -471,6 +471,7 @@ void GameList::AddGamePopup(QMenu& context_menu, u64 program_id, std::string pat
     QAction* open_lfs_location = context_menu.addAction(tr("Open Mod Data Location"));
     QAction* open_transferable_shader_cache =
         context_menu.addAction(tr("Open Transferable Shader Cache"));
+    QAction* open_rescaling_profile_cache = context_menu.addAction(tr("Open Rescaling Profile"));
     context_menu.addSeparator();
     QAction* dump_romfs = context_menu.addAction(tr("Dump RomFS"));
     QAction* copy_tid = context_menu.addAction(tr("Copy Title ID to Clipboard"));
@@ -490,6 +491,8 @@ void GameList::AddGamePopup(QMenu& context_menu, u64 program_id, std::string pat
     });
     connect(open_transferable_shader_cache, &QAction::triggered,
             [this, program_id]() { emit OpenTransferableShaderCacheRequested(program_id); });
+    connect(open_rescaling_profile_cache, &QAction::triggered,
+            [this, program_id]() { emit OpenResolutionProfileRequested(program_id); });
     connect(dump_romfs, &QAction::triggered,
             [this, program_id, path]() { emit DumpRomFSRequested(program_id, path); });
     connect(copy_tid, &QAction::triggered,

src/yuzu/game_list.h

@@ -75,6 +75,7 @@ signals:
     void ShouldCancelWorker();
     void OpenFolderRequested(u64 program_id, GameListOpenTarget target);
     void OpenTransferableShaderCacheRequested(u64 program_id);
+    void OpenResolutionProfileRequested(u64 program_id);
     void DumpRomFSRequested(u64 program_id, const std::string& game_path);
     void CopyTIDRequested(u64 program_id);
     void NavigateToGamedbEntryRequested(u64 program_id,

src/yuzu/main.cpp

@@ -681,6 +681,8 @@ void GMainWindow::ConnectWidgetEvents() {
     connect(game_list, &GameList::OpenFolderRequested, this, &GMainWindow::OnGameListOpenFolder);
     connect(game_list, &GameList::OpenTransferableShaderCacheRequested, this,
             &GMainWindow::OnTransferableShaderCacheOpenFile);
+    connect(game_list, &GameList::OpenResolutionProfileRequested, this,
+            &GMainWindow::OnResolutionProfileOpenFile);
     connect(game_list, &GameList::DumpRomFSRequested, this, &GMainWindow::OnGameListDumpRomFS);
     connect(game_list, &GameList::CopyTIDRequested, this, &GMainWindow::OnGameListCopyTID);
     connect(game_list, &GameList::NavigateToGamedbEntryRequested, this,
@@ -1147,6 +1149,23 @@ void GMainWindow::OnGameListOpenFolder(u64 program_id, GameListOpenTarget target
     QDesktopServices::openUrl(QUrl::fromLocalFile(qpath));
 }
 
+void DisplayOrSelect(const QString& folder_path, const QString& file_path) {
+// Windows supports opening a folder with selecting a specified file in explorer. On every other
+// OS we just open the transferable shader cache folder without preselecting the transferable
+// shader cache file for the selected game.
+#if defined(Q_OS_WIN)
+    const QString explorer = QStringLiteral("explorer");
+    QStringList param;
+    if (!QFileInfo(file_path).isDir()) {
+        param << QStringLiteral("/select,");
+    }
+    param << QDir::toNativeSeparators(file_path);
+    QProcess::startDetached(explorer, param);
+#else
+    QDesktopServices::openUrl(QUrl::fromLocalFile(folder_path));
+#endif
+}
+
 void GMainWindow::OnTransferableShaderCacheOpenFile(u64 program_id) {
     ASSERT(program_id != 0);
 
@@ -1164,20 +1183,24 @@ void GMainWindow::OnTransferableShaderCacheOpenFile(u64 program_id) {
         return;
     }
 
-    // Windows supports opening a folder with selecting a specified file in explorer. On every other
-    // OS we just open the transferable shader cache folder without preselecting the transferable
-    // shader cache file for the selected game.
-#if defined(Q_OS_WIN)
-    const QString explorer = QStringLiteral("explorer");
-    QStringList param;
-    if (!QFileInfo(transferable_shader_cache_file_path).isDir()) {
-        param << QStringLiteral("/select,");
+    DisplayOrSelect(tranferable_shader_cache_folder_path, transferable_shader_cache_file_path);
+}
+
+void GMainWindow::OnResolutionProfileOpenFile(u64 program_id) {
+    ASSERT(program_id != 0);
+
+    const QString rescaling_dir =
+        QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::RescalingDir));
+    const QString rescaling_profile_file_path =
+        rescaling_dir + QString::fromStdString(fmt::format("{:016X}.json", program_id));
+
+    if (!QFile::exists(rescaling_profile_file_path)) {
+        QMessageBox::warning(this, tr("Error Opening Rescaling Profile"),
+                             tr("A rescaling profile for this title does not exist."));
+        return;
     }
-    param << QDir::toNativeSeparators(transferable_shader_cache_file_path);
-    QProcess::startDetached(explorer, param);
-#else
-    QDesktopServices::openUrl(QUrl::fromLocalFile(tranferable_shader_cache_folder_path));
-#endif
+
+    DisplayOrSelect(rescaling_dir, rescaling_profile_file_path);
 }
 
 static std::size_t CalculateRomFSEntrySize(const FileSys::VirtualDir& dir, bool full) {

src/yuzu/main.h

@@ -185,6 +185,7 @@ private slots:
     void OnGameListLoadFile(QString game_path);
     void OnGameListOpenFolder(u64 program_id, GameListOpenTarget target);
     void OnTransferableShaderCacheOpenFile(u64 program_id);
+    void OnResolutionProfileOpenFile(u64 program_id);
     void OnGameListDumpRomFS(u64 program_id, const std::string& game_path);
     void OnGameListCopyTID(u64 program_id);
     void OnGameListNavigateToGamedbEntry(u64 program_id,