Fix clang format and MacOS build

src/audio_core/stream.cpp

@@ -11,6 +11,7 @@
 #include "audio_core/stream.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
+#include "common/microprofile.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/settings.h"
@@ -103,7 +104,10 @@ void Stream::PlayNextBuffer() {
     CoreTiming::ScheduleEventThreadsafe(GetBufferReleaseCycles(*active_buffer), release_event, {});
 }
 
+MICROPROFILE_DEFINE(AudioOutput, "Audio", "ReleaseActiveBuffer", MP_RGB(100, 100, 255));
+
 void Stream::ReleaseActiveBuffer() {
+    MICROPROFILE_SCOPE(AudioOutput);
     ASSERT(active_buffer);
     released_buffers.push(std::move(active_buffer));
     release_callback();

src/audio_core/time_stretch.cpp

@@ -32,10 +32,10 @@ std::size_t TimeStretcher::Process(const s16* in, std::size_t num_in, s16* out,
     // We were given actual_samples number of samples, and num_samples were requested from us.
     double current_ratio = static_cast<double>(num_in) / static_cast<double>(num_out);
 
-    const double max_latency = 0.25; // seconds
+    const double max_latency = 1.0; // seconds
     const double max_backlog = m_sample_rate * max_latency;
     const double backlog_fullness = m_sound_touch.numSamples() / max_backlog;
-    if (backlog_fullness > 4.0) {
+    if (backlog_fullness > 5.0) {
         // Too many samples in backlog: Don't push anymore on
         num_in = 0;
     }
@@ -49,7 +49,7 @@ std::size_t TimeStretcher::Process(const s16* in, std::size_t num_in, s16* out,
 
     // This low-pass filter smoothes out variance in the calculated stretch ratio.
     // The time-scale determines how responsive this filter is.
-    constexpr double lpf_time_scale = 0.712; // seconds
+    constexpr double lpf_time_scale = 2.0; // seconds
     const double lpf_gain = 1.0 - std::exp(-time_delta / lpf_time_scale);
     m_stretch_ratio += lpf_gain * (current_ratio - m_stretch_ratio);
 

src/common/logging/backend.cpp

@@ -12,8 +12,7 @@
 #include <thread>
 #include <vector>
 #ifdef _WIN32
-#include <share.h>   // For _SH_DENYWR
-#include <windows.h> // For OutputDebugStringA
+#include <share.h> // For _SH_DENYWR
 #else
 #define _SH_DENYWR 0
 #endif
@@ -140,18 +139,12 @@ void FileBackend::Write(const Entry& entry) {
     if (!file.IsOpen() || bytes_written > MAX_BYTES_WRITTEN) {
         return;
     }
-    bytes_written += file.WriteString(FormatLogMessage(entry).append(1, '\n'));
+    bytes_written += file.WriteString(FormatLogMessage(entry) + '\n');
     if (entry.log_level >= Level::Error) {
         file.Flush();
     }
 }
 
-void DebuggerBackend::Write(const Entry& entry) {
-#ifdef _WIN32
-    ::OutputDebugStringA(FormatLogMessage(entry).append(1, '\n').c_str());
-#endif
-}
-
 /// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
 #define ALL_LOG_CLASSES()                                                                          \
     CLS(Log)                                                                                       \

src/common/logging/backend.h

@@ -103,20 +103,6 @@ private:
     std::size_t bytes_written;
 };
 
-/**
- * Backend that writes to Visual Studio's output window
- */
-class DebuggerBackend : public Backend {
-public:
-    static const char* Name() {
-        return "debugger";
-    }
-    const char* GetName() const override {
-        return Name();
-    }
-    void Write(const Entry& entry) override;
-};
-
 void AddBackend(std::unique_ptr<Backend> backend);
 
 void RemoveBackend(std::string_view backend_name);

src/common/telemetry.h

@@ -153,7 +153,6 @@ struct VisitorInterface : NonCopyable {
 
     /// Completion method, called once all fields have been visited
     virtual void Complete() = 0;
-    virtual bool SubmitTestcase() = 0;
 };
 
 /**
@@ -179,9 +178,6 @@ struct NullVisitor : public VisitorInterface {
     void Visit(const Field<std::chrono::microseconds>& /*field*/) override {}
 
     void Complete() override {}
-    bool SubmitTestcase() override {
-        return false;
-    }
 };
 
 /// Appends build-specific information to the given FieldCollection,

src/core/core.cpp

@@ -312,10 +312,6 @@ Cpu& System::CurrentCpuCore() {
     return impl->CurrentCpuCore();
 }
 
-const Cpu& System::CurrentCpuCore() const {
-    return impl->CurrentCpuCore();
-}
-
 System::ResultStatus System::RunLoop(bool tight_loop) {
     return impl->RunLoop(tight_loop);
 }
@@ -346,11 +342,7 @@ PerfStatsResults System::GetAndResetPerfStats() {
     return impl->GetAndResetPerfStats();
 }
 
-TelemetrySession& System::TelemetrySession() {
-    return *impl->telemetry_session;
-}
-
-const TelemetrySession& System::TelemetrySession() const {
+Core::TelemetrySession& System::TelemetrySession() const {
     return *impl->telemetry_session;
 }
 
@@ -358,11 +350,7 @@ ARM_Interface& System::CurrentArmInterface() {
     return CurrentCpuCore().ArmInterface();
 }
 
-const ARM_Interface& System::CurrentArmInterface() const {
-    return CurrentCpuCore().ArmInterface();
-}
-
-std::size_t System::CurrentCoreIndex() const {
+std::size_t System::CurrentCoreIndex() {
     return CurrentCpuCore().CoreIndex();
 }
 
@@ -370,10 +358,6 @@ Kernel::Scheduler& System::CurrentScheduler() {
     return CurrentCpuCore().Scheduler();
 }
 
-const Kernel::Scheduler& System::CurrentScheduler() const {
-    return CurrentCpuCore().Scheduler();
-}
-
 Kernel::Scheduler& System::Scheduler(std::size_t core_index) {
     return CpuCore(core_index).Scheduler();
 }
@@ -394,10 +378,6 @@ ARM_Interface& System::ArmInterface(std::size_t core_index) {
     return CpuCore(core_index).ArmInterface();
 }
 
-const ARM_Interface& System::ArmInterface(std::size_t core_index) const {
-    return CpuCore(core_index).ArmInterface();
-}
-
 Cpu& System::CpuCore(std::size_t core_index) {
     ASSERT(core_index < NUM_CPU_CORES);
     return *impl->cpu_cores[core_index];
@@ -412,10 +392,6 @@ ExclusiveMonitor& System::Monitor() {
     return *impl->cpu_exclusive_monitor;
 }
 
-const ExclusiveMonitor& System::Monitor() const {
-    return *impl->cpu_exclusive_monitor;
-}
-
 Tegra::GPU& System::GPU() {
     return *impl->gpu_core;
 }

src/core/core.h

@@ -129,11 +129,11 @@ public:
      */
     bool IsPoweredOn() const;
 
-    /// Gets a reference to the telemetry session for this emulation session.
-    Core::TelemetrySession& TelemetrySession();
-
-    /// Gets a reference to the telemetry session for this emulation session.
-    const Core::TelemetrySession& TelemetrySession() const;
+    /**
+     * Returns a reference to the telemetry session for this emulation session.
+     * @returns Reference to the telemetry session.
+     */
+    Core::TelemetrySession& TelemetrySession() const;
 
     /// Prepare the core emulation for a reschedule
     void PrepareReschedule();
@@ -144,36 +144,24 @@ public:
     /// Gets an ARM interface to the CPU core that is currently running
     ARM_Interface& CurrentArmInterface();
 
-    /// Gets an ARM interface to the CPU core that is currently running
-    const ARM_Interface& CurrentArmInterface() const;
-
     /// Gets the index of the currently running CPU core
-    std::size_t CurrentCoreIndex() const;
+    std::size_t CurrentCoreIndex();
 
     /// Gets the scheduler for the CPU core that is currently running
     Kernel::Scheduler& CurrentScheduler();
 
-    /// Gets the scheduler for the CPU core that is currently running
-    const Kernel::Scheduler& CurrentScheduler() const;
-
-    /// Gets a reference to an ARM interface for the CPU core with the specified index
+    /// Gets an ARM interface to the CPU core with the specified index
     ARM_Interface& ArmInterface(std::size_t core_index);
 
-    /// Gets a const reference to an ARM interface from the CPU core with the specified index
-    const ARM_Interface& ArmInterface(std::size_t core_index) const;
-
     /// Gets a CPU interface to the CPU core with the specified index
     Cpu& CpuCore(std::size_t core_index);
 
     /// Gets a CPU interface to the CPU core with the specified index
     const Cpu& CpuCore(std::size_t core_index) const;
 
-    /// Gets a reference to the exclusive monitor
+    /// Gets the exclusive monitor
     ExclusiveMonitor& Monitor();
 
-    /// Gets a constant reference to the exclusive monitor
-    const ExclusiveMonitor& Monitor() const;
-
     /// Gets a mutable reference to the GPU interface
     Tegra::GPU& GPU();
 
@@ -242,9 +230,6 @@ private:
     /// Returns the currently running CPU core
     Cpu& CurrentCpuCore();
 
-    /// Returns the currently running CPU core
-    const Cpu& CurrentCpuCore() const;
-
     /**
      * Initialize the emulated system.
      * @param emu_window Reference to the host-system window used for video output and keyboard

src/core/file_sys/fsmitm_romfsbuild.h

@@ -27,6 +27,7 @@
 #include <map>
 #include <memory>
 #include <string>
+#include <boost/detail/container_fwd.hpp>
 #include "common/common_types.h"
 #include "core/file_sys/vfs.h"
 

src/core/hle/ipc_helpers.h

@@ -117,7 +117,8 @@ public:
 
         AlignWithPadding();
 
-        if (context.Session()->IsDomain() && context.HasDomainMessageHeader()) {
+        const bool request_has_domain_header{context.GetDomainMessageHeader() != nullptr};
+        if (context.Session()->IsDomain() && request_has_domain_header) {
             IPC::DomainMessageHeader domain_header{};
             domain_header.num_objects = num_domain_objects;
             PushRaw(domain_header);

src/core/hle/kernel/hle_ipc.h

@@ -161,12 +161,8 @@ public:
         return buffer_c_desciptors;
     }
 
-    const IPC::DomainMessageHeader* GetDomainMessageHeader() const {
-        return domain_message_header.get();
-    }
-
-    bool HasDomainMessageHeader() const {
-        return domain_message_header != nullptr;
+    const std::shared_ptr<IPC::DomainMessageHeader>& GetDomainMessageHeader() const {
+        return domain_message_header;
     }
 
     /// Helper function to read a buffer using the appropriate buffer descriptor

src/core/hle/kernel/kernel.cpp

@@ -32,7 +32,7 @@ namespace Kernel {
  */
 static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] int cycles_late) {
     const auto proper_handle = static_cast<Handle>(thread_handle);
-    const auto& system = Core::System::GetInstance();
+    auto& system = Core::System::GetInstance();
 
     // Lock the global kernel mutex when we enter the kernel HLE.
     std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
@@ -90,7 +90,7 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] int cycles_
 /// The timer callback event, called when a timer is fired
 static void TimerCallback(u64 timer_handle, int cycles_late) {
     const auto proper_handle = static_cast<Handle>(timer_handle);
-    const auto& system = Core::System::GetInstance();
+    auto& system = Core::System::GetInstance();
     SharedPtr<Timer> timer = system.Kernel().RetrieveTimerFromCallbackHandleTable(proper_handle);
 
     if (timer == nullptr) {

src/core/hle/kernel/mutex.cpp

@@ -6,6 +6,8 @@
 #include <utility>
 #include <vector>
 
+#include <boost/range/algorithm_ext/erase.hpp>
+
 #include "common/assert.h"
 #include "core/core.h"
 #include "core/hle/kernel/errors.h"

src/core/hle/kernel/server_session.cpp

@@ -63,7 +63,7 @@ void ServerSession::Acquire(Thread* thread) {
 }
 
 ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& context) {
-    auto* const domain_message_header = context.GetDomainMessageHeader();
+    auto& domain_message_header = context.GetDomainMessageHeader();
     if (domain_message_header) {
         // Set domain handlers in HLE context, used for domain objects (IPC interfaces) as inputs
         context.SetDomainRequestHandlers(domain_request_handlers);
@@ -111,7 +111,7 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
 
     ResultCode result = RESULT_SUCCESS;
     // If the session has been converted to a domain, handle the domain request
-    if (IsDomain() && context.HasDomainMessageHeader()) {
+    if (IsDomain() && context.GetDomainMessageHeader()) {
         result = HandleDomainSyncRequest(context);
         // If there is no domain header, the regular session handler is used
     } else if (hle_handler != nullptr) {

src/core/hle/kernel/svc.cpp

@@ -572,7 +572,7 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
             return ERR_INVALID_HANDLE;
         }
 
-        const auto& system = Core::System::GetInstance();
+        auto& system = Core::System::GetInstance();
         const auto& scheduler = system.CurrentScheduler();
         const auto* const current_thread = scheduler.GetCurrentThread();
         const bool same_thread = current_thread == thread;

src/core/hle/service/acc/profile_manager.h

@@ -57,8 +57,7 @@ struct UUID {
 };
 static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");
 
-constexpr std::size_t profile_username_size = 32;
-using ProfileUsername = std::array<u8, profile_username_size>;
+using ProfileUsername = std::array<u8, 0x20>;
 using ProfileData = std::array<u8, MAX_DATA>;
 using UserIDArray = std::array<UUID, MAX_USERS>;
 

src/core/hle/service/audio/hwopus.cpp

@@ -161,7 +161,7 @@ void HwOpus::OpenOpusDecoder(Kernel::HLERequestContext& ctx) {
     ASSERT_MSG(channel_count == 1 || channel_count == 2, "Invalid channel count");
 
     std::size_t worker_sz = WorkerBufferSize(channel_count);
-    ASSERT_MSG(buffer_sz >= worker_sz, "Worker buffer too large");
+    ASSERT_MSG(buffer_sz < worker_sz, "Worker buffer too large");
     std::unique_ptr<OpusDecoder, OpusDeleter> decoder{
         static_cast<OpusDecoder*>(operator new(worker_sz))};
     if (opus_decoder_init(decoder.get(), sample_rate, channel_count)) {

src/core/hle/service/hid/controllers/npad.cpp

@@ -427,9 +427,6 @@ void Controller_NPad::VibrateController(const std::vector<u32>& controller_ids,
 }
 
 Kernel::SharedPtr<Kernel::Event> Controller_NPad::GetStyleSetChangedEvent() const {
-    // TODO(ogniK): Figure out the best time to signal this event. This event seems that it should
-    // be signalled at least once, and signaled after a new controller is connected?
-    styleset_changed_event->Signal();
     return styleset_changed_event;
 }
 

src/core/hle/service/hid/hid.cpp

@@ -96,8 +96,6 @@ public:
         // TODO(shinyquagsire23): Other update callbacks? (accel, gyro?)
 
         CoreTiming::ScheduleEvent(pad_update_ticks, pad_update_event);
-
-        ReloadInputDevices();
     }
 
     void ActivateController(HidController controller) {

src/core/hle/service/nvflinger/buffer_queue.h

@@ -58,9 +58,9 @@ public:
         /// Rotate source image 90 degrees clockwise
         Rotate90 = 0x04,
         /// Rotate source image 180 degrees
-        Rotate180 = 0x03,
+        Roate180 = 0x03,
         /// Rotate source image 270 degrees clockwise
-        Rotate270 = 0x07,
+        Roate270 = 0x07,
     };
 
     struct Buffer {

src/core/hle/service/usb/usb.cpp

@@ -132,11 +132,11 @@ public:
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, nullptr, "BindNoticeEvent"},
-            {1, nullptr, "UnbindNoticeEvent"},
+            {1, nullptr, "Unknown1"},
             {2, nullptr, "GetStatus"},
             {3, nullptr, "GetNotice"},
-            {4, nullptr, "EnablePowerRequestNotice"},
-            {5, nullptr, "DisablePowerRequestNotice"},
+            {4, nullptr, "Unknown2"},
+            {5, nullptr, "Unknown3"},
             {6, nullptr, "ReplyPowerRequest"},
         };
         // clang-format on

src/core/telemetry_session.cpp

@@ -184,13 +184,4 @@ TelemetrySession::~TelemetrySession() {
     backend = nullptr;
 }
 
-bool TelemetrySession::SubmitTestcase() {
-#ifdef ENABLE_WEB_SERVICE
-    field_collection.Accept(*backend);
-    return backend->SubmitTestcase();
-#else
-    return false;
-#endif
-}
-
 } // namespace Core

src/core/telemetry_session.h

@@ -31,12 +31,6 @@ public:
         field_collection.AddField(type, name, std::move(value));
     }
 
-    /**
-     * Submits a Testcase.
-     * @returns A bool indicating whether the submission succeeded
-     */
-    bool SubmitTestcase();
-
 private:
     Telemetry::FieldCollection field_collection; ///< Tracks all added fields for the session
     std::unique_ptr<Telemetry::VisitorInterface> backend; ///< Backend interface that logs fields

src/video_core/CMakeLists.txt

@@ -33,7 +33,6 @@ add_library(video_core STATIC
     renderer_opengl/gl_rasterizer.h
     renderer_opengl/gl_rasterizer_cache.cpp
     renderer_opengl/gl_rasterizer_cache.h
-    renderer_opengl/gl_resource_manager.cpp
     renderer_opengl/gl_resource_manager.h
     renderer_opengl/gl_shader_cache.cpp
     renderer_opengl/gl_shader_cache.h
@@ -52,10 +51,6 @@ add_library(video_core STATIC
     renderer_opengl/maxwell_to_gl.h
     renderer_opengl/renderer_opengl.cpp
     renderer_opengl/renderer_opengl.h
-    renderer_opengl/utils.cpp
-    renderer_opengl/utils.h
-    surface.cpp
-    surface.h
     textures/astc.cpp
     textures/astc.h
     textures/decoders.cpp

src/video_core/engines/maxwell_3d.cpp

@@ -43,17 +43,15 @@ void Maxwell3D::CallMacroMethod(u32 method, std::vector<u32> parameters) {
     // Reset the current macro.
     executing_macro = 0;
 
-    // Lookup the macro offset
-    const u32 entry{(method - MacroRegistersStart) >> 1};
-    const auto& search{macro_offsets.find(entry)};
-    if (search == macro_offsets.end()) {
-        LOG_CRITICAL(HW_GPU, "macro not found for method 0x{:X}!", method);
-        UNREACHABLE();
+    // The requested macro must have been uploaded already.
+    auto macro_code = uploaded_macros.find(method);
+    if (macro_code == uploaded_macros.end()) {
+        LOG_ERROR(HW_GPU, "Macro {:04X} was not uploaded", method);
         return;
     }
 
     // Execute the current macro.
-    macro_interpreter.Execute(search->second, std::move(parameters));
+    macro_interpreter.Execute(macro_code->second, std::move(parameters));
 }
 
 void Maxwell3D::WriteReg(u32 method, u32 value, u32 remaining_params) {
@@ -99,10 +97,6 @@ void Maxwell3D::WriteReg(u32 method, u32 value, u32 remaining_params) {
         ProcessMacroUpload(value);
         break;
     }
-    case MAXWELL3D_REG_INDEX(macros.bind): {
-        ProcessMacroBind(value);
-        break;
-    }
     case MAXWELL3D_REG_INDEX(const_buffer.cb_data[0]):
     case MAXWELL3D_REG_INDEX(const_buffer.cb_data[1]):
     case MAXWELL3D_REG_INDEX(const_buffer.cb_data[2]):
@@ -164,13 +158,9 @@ void Maxwell3D::WriteReg(u32 method, u32 value, u32 remaining_params) {
 }
 
 void Maxwell3D::ProcessMacroUpload(u32 data) {
-    ASSERT_MSG(regs.macros.upload_address < macro_memory.size(),
-               "upload_address exceeded macro_memory size!");
-    macro_memory[regs.macros.upload_address++] = data;
-}
-
-void Maxwell3D::ProcessMacroBind(u32 data) {
-    macro_offsets[regs.macros.entry] = data;
+    // Store the uploaded macro code to interpret them when they're called.
+    auto& macro = uploaded_macros[regs.macros.entry * 2 + MacroRegistersStart];
+    macro.push_back(data);
 }
 
 void Maxwell3D::ProcessQueryGet() {

src/video_core/engines/maxwell_3d.h

@@ -475,13 +475,12 @@ public:
                 INSERT_PADDING_WORDS(0x45);
 
                 struct {
-                    u32 upload_address;
+                    INSERT_PADDING_WORDS(1);
                     u32 data;
                     u32 entry;
-                    u32 bind;
                 } macros;
 
-                INSERT_PADDING_WORDS(0x188);
+                INSERT_PADDING_WORDS(0x189);
 
                 u32 tfb_enabled;
 
@@ -995,25 +994,12 @@ public:
     /// Returns the texture information for a specific texture in a specific shader stage.
     Texture::FullTextureInfo GetStageTexture(Regs::ShaderStage stage, std::size_t offset) const;
 
-    /// Memory for macro code - it's undetermined how big this is, however 1MB is much larger than
-    /// we've seen used.
-    using MacroMemory = std::array<u32, 0x40000>;
-
-    /// Gets a reference to macro memory.
-    const MacroMemory& GetMacroMemory() const {
-        return macro_memory;
-    }
-
 private:
     void InitializeRegisterDefaults();
 
     VideoCore::RasterizerInterface& rasterizer;
 
-    /// Start offsets of each macro in macro_memory
-    std::unordered_map<u32, u32> macro_offsets;
-
-    /// Memory for macro code
-    MacroMemory macro_memory;
+    std::unordered_map<u32, std::vector<u32>> uploaded_macros;
 
     /// Macro method that is currently being executed / being fed parameters.
     u32 executing_macro = 0;
@@ -1036,12 +1022,9 @@ private:
      */
     void CallMacroMethod(u32 method, std::vector<u32> parameters);
 
-    /// Handles writes to the macro uploading register.
+    /// Handles writes to the macro uploading registers.
     void ProcessMacroUpload(u32 data);
 
-    /// Handles writes to the macro bind register.
-    void ProcessMacroBind(u32 data);
-
     /// Handles a write to the CLEAR_BUFFERS register.
     void ProcessClearBuffers();
 

src/video_core/engines/shader_bytecode.h

@@ -577,10 +577,6 @@ union Instruction {
         BitField<55, 1, u64> saturate;
     } fmul32;
 
-    union {
-        BitField<52, 1, u64> generates_cc;
-    } op_32;
-
     union {
         BitField<48, 1, u64> is_signed;
     } shift;
@@ -1235,7 +1231,6 @@ union Instruction {
     BitField<60, 1, u64> is_b_gpr;
     BitField<59, 1, u64> is_c_gpr;
     BitField<20, 24, s64> smem_imm;
-    BitField<0, 5, ControlCode> flow_control_code;
 
     Attribute attribute;
     Sampler sampler;
@@ -1663,4 +1658,4 @@ private:
     }
 };
 
-} // namespace Tegra::Shader
+} // namespace Tegra::Shader

src/video_core/macro_interpreter.cpp

@@ -11,7 +11,7 @@ namespace Tegra {
 
 MacroInterpreter::MacroInterpreter(Engines::Maxwell3D& maxwell3d) : maxwell3d(maxwell3d) {}
 
-void MacroInterpreter::Execute(u32 offset, std::vector<u32> parameters) {
+void MacroInterpreter::Execute(const std::vector<u32>& code, std::vector<u32> parameters) {
     Reset();
     registers[1] = parameters[0];
     this->parameters = std::move(parameters);
@@ -19,7 +19,7 @@ void MacroInterpreter::Execute(u32 offset, std::vector<u32> parameters) {
     // Execute the code until we hit an exit condition.
     bool keep_executing = true;
     while (keep_executing) {
-        keep_executing = Step(offset, false);
+        keep_executing = Step(code, false);
     }
 
     // Assert the the macro used all the input parameters
@@ -37,10 +37,10 @@ void MacroInterpreter::Reset() {
     next_parameter_index = 1;
 }
 
-bool MacroInterpreter::Step(u32 offset, bool is_delay_slot) {
+bool MacroInterpreter::Step(const std::vector<u32>& code, bool is_delay_slot) {
     u32 base_address = pc;
 
-    Opcode opcode = GetOpcode(offset);
+    Opcode opcode = GetOpcode(code);
     pc += 4;
 
     // Update the program counter if we were delayed
@@ -108,7 +108,7 @@ bool MacroInterpreter::Step(u32 offset, bool is_delay_slot) {
 
             delayed_pc = base_address + opcode.GetBranchTarget();
             // Execute one more instruction due to the delay slot.
-            return Step(offset, true);
+            return Step(code, true);
         }
         break;
     }
@@ -121,18 +121,17 @@ bool MacroInterpreter::Step(u32 offset, bool is_delay_slot) {
         // Exit has a delay slot, execute the next instruction
         // Note: Executing an exit during a branch delay slot will cause the instruction at the
         // branch target to be executed before exiting.
-        Step(offset, true);
+        Step(code, true);
         return false;
     }
 
     return true;
 }
 
-MacroInterpreter::Opcode MacroInterpreter::GetOpcode(u32 offset) const {
-    const auto& macro_memory{maxwell3d.GetMacroMemory()};
+MacroInterpreter::Opcode MacroInterpreter::GetOpcode(const std::vector<u32>& code) const {
     ASSERT((pc % sizeof(u32)) == 0);
-    ASSERT((pc + offset) < macro_memory.size() * sizeof(u32));
-    return {macro_memory[offset + pc / sizeof(u32)]};
+    ASSERT(pc < code.size() * sizeof(u32));
+    return {code[pc / sizeof(u32)]};
 }
 
 u32 MacroInterpreter::GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) const {

src/video_core/macro_interpreter.h

@@ -22,10 +22,10 @@ public:
 
     /**
      * Executes the macro code with the specified input parameters.
-     * @param offset Offset to start execution at.
-     * @param parameters The parameters of the macro.
+     * @param code The macro byte code to execute
+     * @param parameters The parameters of the macro
      */
-    void Execute(u32 offset, std::vector<u32> parameters);
+    void Execute(const std::vector<u32>& code, std::vector<u32> parameters);
 
 private:
     enum class Operation : u32 {
@@ -110,11 +110,11 @@ private:
     /**
      * Executes a single macro instruction located at the current program counter. Returns whether
      * the interpreter should keep running.
-     * @param offset Offset to start execution at.
+     * @param code The macro code to execute.
      * @param is_delay_slot Whether the current step is being executed due to a delay slot in a
      * previous instruction.
      */
-    bool Step(u32 offset, bool is_delay_slot);
+    bool Step(const std::vector<u32>& code, bool is_delay_slot);
 
     /// Calculates the result of an ALU operation. src_a OP src_b;
     u32 GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) const;
@@ -127,7 +127,7 @@ private:
     bool EvaluateBranchCondition(BranchCondition cond, u32 value) const;
 
     /// Reads an opcode at the current program counter location.
-    Opcode GetOpcode(u32 offset) const;
+    Opcode GetOpcode(const std::vector<u32>& code) const;
 
     /// Returns the specified register's value. Register 0 is hardcoded to always return 0.
     u32 GetRegister(u32 register_id) const;

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -30,8 +30,8 @@
 namespace OpenGL {
 
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;
-using PixelFormat = VideoCore::Surface::PixelFormat;
-using SurfaceType = VideoCore::Surface::SurfaceType;
+using PixelFormat = SurfaceParams::PixelFormat;
+using SurfaceType = SurfaceParams::SurfaceType;
 
 MICROPROFILE_DEFINE(OpenGL_VAO, "OpenGL", "Vertex Array Setup", MP_RGB(128, 128, 192));
 MICROPROFILE_DEFINE(OpenGL_Shader, "OpenGL", "Shader Setup", MP_RGB(128, 128, 192));
@@ -104,7 +104,7 @@ RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& window, ScreenInfo
     }
 
     ASSERT_MSG(has_ARB_separate_shader_objects, "has_ARB_separate_shader_objects is unsupported");
-    OpenGLState::ApplyDefaultState();
+
     // Clipping plane 0 is always enabled for PICA fixed clip plane z <= 0
     state.clip_distance[0] = true;
 
@@ -115,6 +115,8 @@ RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& window, ScreenInfo
     state.draw.shader_program = 0;
     state.Apply();
 
+    glEnable(GL_BLEND);
+
     glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &uniform_buffer_alignment);
 
     LOG_CRITICAL(Render_OpenGL, "Sync fixed function OpenGL state here!");
@@ -701,8 +703,7 @@ bool RasterizerOpenGL::AccelerateDisplay(const Tegra::FramebufferConfig& config,
 
     // Verify that the cached surface is the same size and format as the requested framebuffer
     const auto& params{surface->GetSurfaceParams()};
-    const auto& pixel_format{
-        VideoCore::Surface::PixelFormatFromGPUPixelFormat(config.pixel_format)};
+    const auto& pixel_format{SurfaceParams::PixelFormatFromGPUPixelFormat(config.pixel_format)};
     ASSERT_MSG(params.width == config.width, "Framebuffer width is different");
     ASSERT_MSG(params.height == config.height, "Framebuffer height is different");
     ASSERT_MSG(params.pixel_format == pixel_format, "Framebuffer pixel_format is different");
@@ -730,15 +731,11 @@ void RasterizerOpenGL::SamplerInfo::SyncWithConfig(const Tegra::Texture::TSCEntr
 
     if (mag_filter != config.mag_filter) {
         mag_filter = config.mag_filter;
-        glSamplerParameteri(
-            s, GL_TEXTURE_MAG_FILTER,
-            MaxwellToGL::TextureFilterMode(mag_filter, Tegra::Texture::TextureMipmapFilter::None));
+        glSamplerParameteri(s, GL_TEXTURE_MAG_FILTER, MaxwellToGL::TextureFilterMode(mag_filter));
     }
-    if (min_filter != config.min_filter || mip_filter != config.mip_filter) {
+    if (min_filter != config.min_filter) {
         min_filter = config.min_filter;
-        mip_filter = config.mip_filter;
-        glSamplerParameteri(s, GL_TEXTURE_MIN_FILTER,
-                            MaxwellToGL::TextureFilterMode(min_filter, mip_filter));
+        glSamplerParameteri(s, GL_TEXTURE_MIN_FILTER, MaxwellToGL::TextureFilterMode(min_filter));
     }
 
     if (wrap_u != config.wrap_u) {

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -93,7 +93,6 @@ private:
     private:
         Tegra::Texture::TextureFilter mag_filter;
         Tegra::Texture::TextureFilter min_filter;
-        Tegra::Texture::TextureMipmapFilter mip_filter;
         Tegra::Texture::WrapMode wrap_u;
         Tegra::Texture::WrapMode wrap_v;
         Tegra::Texture::WrapMode wrap_p;

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -16,22 +16,15 @@
 #include "core/settings.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_opengl/gl_rasterizer_cache.h"
-#include "video_core/renderer_opengl/gl_state.h"
-#include "video_core/renderer_opengl/utils.h"
-#include "video_core/surface.h"
 #include "video_core/textures/astc.h"
 #include "video_core/textures/decoders.h"
 #include "video_core/utils.h"
 
 namespace OpenGL {
 
-using VideoCore::Surface::ComponentTypeFromDepthFormat;
-using VideoCore::Surface::ComponentTypeFromRenderTarget;
-using VideoCore::Surface::ComponentTypeFromTexture;
-using VideoCore::Surface::PixelFormatFromDepthFormat;
-using VideoCore::Surface::PixelFormatFromRenderTargetFormat;
-using VideoCore::Surface::PixelFormatFromTextureFormat;
-using VideoCore::Surface::SurfaceTargetFromTextureType;
+using SurfaceType = SurfaceParams::SurfaceType;
+using PixelFormat = SurfaceParams::PixelFormat;
+using ComponentType = SurfaceParams::ComponentType;
 
 struct FormatTuple {
     GLint internal_format;
@@ -41,6 +34,46 @@ struct FormatTuple {
     bool compressed;
 };
 
+static bool IsPixelFormatASTC(PixelFormat format) {
+    switch (format) {
+    case PixelFormat::ASTC_2D_4X4:
+    case PixelFormat::ASTC_2D_5X4:
+    case PixelFormat::ASTC_2D_8X8:
+    case PixelFormat::ASTC_2D_8X5:
+    case PixelFormat::ASTC_2D_4X4_SRGB:
+    case PixelFormat::ASTC_2D_5X4_SRGB:
+    case PixelFormat::ASTC_2D_8X8_SRGB:
+    case PixelFormat::ASTC_2D_8X5_SRGB:
+        return true;
+    default:
+        return false;
+    }
+}
+
+static std::pair<u32, u32> GetASTCBlockSize(PixelFormat format) {
+    switch (format) {
+    case PixelFormat::ASTC_2D_4X4:
+        return {4, 4};
+    case PixelFormat::ASTC_2D_5X4:
+        return {5, 4};
+    case PixelFormat::ASTC_2D_8X8:
+        return {8, 8};
+    case PixelFormat::ASTC_2D_8X5:
+        return {8, 5};
+    case PixelFormat::ASTC_2D_4X4_SRGB:
+        return {4, 4};
+    case PixelFormat::ASTC_2D_5X4_SRGB:
+        return {5, 4};
+    case PixelFormat::ASTC_2D_8X8_SRGB:
+        return {8, 8};
+    case PixelFormat::ASTC_2D_8X5_SRGB:
+        return {8, 5};
+    default:
+        LOG_CRITICAL(HW_GPU, "Unhandled format: {}", static_cast<u32>(format));
+        UNREACHABLE();
+    }
+}
+
 void SurfaceParams::InitCacheParameters(Tegra::GPUVAddr gpu_addr_) {
     auto& memory_manager{Core::System::GetInstance().GPU().MemoryManager()};
     const auto cpu_addr{memory_manager.GpuToCpuAddress(gpu_addr_)};
@@ -57,34 +90,27 @@ void SurfaceParams::InitCacheParameters(Tegra::GPUVAddr gpu_addr_) {
     }
 }
 
-std::size_t SurfaceParams::InnerMipmapMemorySize(u32 mip_level, bool force_gl, bool layer_only,
-                                                 bool uncompressed) const {
-    const u32 tile_x{GetDefaultBlockWidth(pixel_format)};
-    const u32 tile_y{GetDefaultBlockHeight(pixel_format)};
+std::size_t SurfaceParams::InnerMemorySize(bool layer_only) const {
+    const u32 compression_factor{GetCompressionFactor(pixel_format)};
     const u32 bytes_per_pixel{GetBytesPerPixel(pixel_format)};
     u32 m_depth = (layer_only ? 1U : depth);
-    u32 m_width = MipWidth(mip_level);
-    u32 m_height = MipHeight(mip_level);
-    m_width = uncompressed ? m_width : std::max(1U, (m_width + tile_x - 1) / tile_x);
-    m_height = uncompressed ? m_height : std::max(1U, (m_height + tile_y - 1) / tile_y);
-    m_depth = std::max(1U, m_depth >> mip_level);
-    u32 m_block_height = MipBlockHeight(mip_level);
-    u32 m_block_depth = MipBlockDepth(mip_level);
-    return Tegra::Texture::CalculateSize(force_gl ? false : is_tiled, bytes_per_pixel, m_width,
-                                         m_height, m_depth, m_block_height, m_block_depth);
-}
-
-std::size_t SurfaceParams::InnerMemorySize(bool force_gl, bool layer_only,
-                                           bool uncompressed) const {
-    std::size_t block_size_bytes = Tegra::Texture::GetGOBSize() * block_height * block_depth;
-    std::size_t size = 0;
-    for (u32 i = 0; i < max_mip_level; i++) {
-        size += InnerMipmapMemorySize(i, force_gl, layer_only, uncompressed);
+    u32 m_width = std::max(1U, width / compression_factor);
+    u32 m_height = std::max(1U, height / compression_factor);
+    std::size_t size = Tegra::Texture::CalculateSize(is_tiled, bytes_per_pixel, m_width, m_height,
+                                                     m_depth, block_height, block_depth);
+    u32 m_block_height = block_height;
+    u32 m_block_depth = block_depth;
+    std::size_t block_size_bytes = 512 * block_height * block_depth; // 512 is GOB size
+    for (u32 i = 1; i < max_mip_level; i++) {
+        m_width = std::max(1U, m_width / 2);
+        m_height = std::max(1U, m_height / 2);
+        m_depth = std::max(1U, m_depth / 2);
+        m_block_height = std::max(1U, m_block_height / 2);
+        m_block_depth = std::max(1U, m_block_depth / 2);
+        size += Tegra::Texture::CalculateSize(is_tiled, bytes_per_pixel, m_width, m_height, m_depth,
+                                              m_block_height, m_block_depth);
     }
-    if (!force_gl && is_tiled) {
-        size = Common::AlignUp(size, block_size_bytes);
-    }
-    return size;
+    return is_tiled ? Common::AlignUp(size, block_size_bytes) : size;
 }
 
 /*static*/ SurfaceParams SurfaceParams::CreateForTexture(
@@ -127,13 +153,6 @@ std::size_t SurfaceParams::InnerMemorySize(bool force_gl, bool layer_only,
             params.target = SurfaceTarget::Texture2D;
         }
         break;
-    case SurfaceTarget::TextureCubeArray:
-        params.depth = config.tic.Depth() * 6;
-        if (!entry.IsArray()) {
-            ASSERT(params.depth == 6);
-            params.target = SurfaceTarget::TextureCubemap;
-        }
-        break;
     default:
         LOG_CRITICAL(HW_GPU, "Unknown depth for target={}", static_cast<u32>(params.target));
         UNREACHABLE();
@@ -169,7 +188,7 @@ std::size_t SurfaceParams::InnerMemorySize(bool force_gl, bool layer_only,
     params.unaligned_height = config.height;
     params.target = SurfaceTarget::Texture2D;
     params.depth = 1;
-    params.max_mip_level = 1;
+    params.max_mip_level = 0;
     params.is_layered = false;
 
     // Render target specific parameters, not used for caching
@@ -203,7 +222,7 @@ std::size_t SurfaceParams::InnerMemorySize(bool force_gl, bool layer_only,
     params.unaligned_height = zeta_height;
     params.target = SurfaceTarget::Texture2D;
     params.depth = 1;
-    params.max_mip_level = 1;
+    params.max_mip_level = 0;
     params.is_layered = false;
     params.rt = {};
 
@@ -230,7 +249,7 @@ std::size_t SurfaceParams::InnerMemorySize(bool force_gl, bool layer_only,
     params.unaligned_height = config.height;
     params.target = SurfaceTarget::Texture2D;
     params.depth = 1;
-    params.max_mip_level = 1;
+    params.max_mip_level = 0;
     params.rt = {};
 
     params.InitCacheParameters(config.Address());
@@ -238,7 +257,7 @@ std::size_t SurfaceParams::InnerMemorySize(bool force_gl, bool layer_only,
     return params;
 }
 
-static constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> tex_format_tuples = {{
+static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_format_tuples = {{
     {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, ComponentType::UNorm, false}, // ABGR8U
     {GL_RGBA8, GL_RGBA, GL_BYTE, ComponentType::SNorm, false},                     // ABGR8S
     {GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, ComponentType::UInt, false},   // ABGR8UI
@@ -254,7 +273,7 @@ static constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> tex
     {GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, ComponentType::Float,
      false},                                                                     // R11FG11FB10F
     {GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false}, // RGBA32UI
-    {GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
+    {GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
      true}, // DXT1
     {GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
      true}, // DXT23
@@ -299,7 +318,7 @@ static constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> tex
     {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_5X4
     {GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // BGRA8
     // Compressed sRGB formats
-    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
+    {GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
      true}, // DXT1_SRGB
     {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
      true}, // DXT23_SRGB
@@ -311,8 +330,6 @@ static constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> tex
     {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X8_SRGB
     {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X5_SRGB
     {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_5X4_SRGB
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_5X5
-    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_5X5_SRGB
 
     // Depth formats
     {GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT, ComponentType::Float, false}, // Z32F
@@ -328,22 +345,20 @@ static constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> tex
      ComponentType::Float, false}, // Z32FS8
 }};
 
-static GLenum SurfaceTargetToGL(SurfaceTarget target) {
+static GLenum SurfaceTargetToGL(SurfaceParams::SurfaceTarget target) {
     switch (target) {
-    case SurfaceTarget::Texture1D:
+    case SurfaceParams::SurfaceTarget::Texture1D:
         return GL_TEXTURE_1D;
-    case SurfaceTarget::Texture2D:
+    case SurfaceParams::SurfaceTarget::Texture2D:
         return GL_TEXTURE_2D;
-    case SurfaceTarget::Texture3D:
+    case SurfaceParams::SurfaceTarget::Texture3D:
         return GL_TEXTURE_3D;
-    case SurfaceTarget::Texture1DArray:
+    case SurfaceParams::SurfaceTarget::Texture1DArray:
         return GL_TEXTURE_1D_ARRAY;
-    case SurfaceTarget::Texture2DArray:
+    case SurfaceParams::SurfaceTarget::Texture2DArray:
         return GL_TEXTURE_2D_ARRAY;
-    case SurfaceTarget::TextureCubemap:
+    case SurfaceParams::SurfaceTarget::TextureCubemap:
         return GL_TEXTURE_CUBE_MAP;
-    case SurfaceTarget::TextureCubeArray:
-        return GL_TEXTURE_CUBE_MAP_ARRAY_ARB;
     }
     LOG_CRITICAL(Render_OpenGL, "Unimplemented texture target={}", static_cast<u32>(target));
     UNREACHABLE();
@@ -358,41 +373,59 @@ static const FormatTuple& GetFormatTuple(PixelFormat pixel_format, ComponentType
     return format;
 }
 
-MathUtil::Rectangle<u32> SurfaceParams::GetRect(u32 mip_level) const {
-    u32 actual_height{std::max(1U, unaligned_height >> mip_level)};
+MathUtil::Rectangle<u32> SurfaceParams::GetRect() const {
+    u32 actual_height{unaligned_height};
     if (IsPixelFormatASTC(pixel_format)) {
         // ASTC formats must stop at the ATSC block size boundary
         actual_height = Common::AlignDown(actual_height, GetASTCBlockSize(pixel_format).second);
     }
-    return {0, actual_height, MipWidth(mip_level), 0};
+    return {0, actual_height, width, 0};
+}
+
+/// Returns true if the specified PixelFormat is a BCn format, e.g. DXT or DXN
+static bool IsFormatBCn(PixelFormat format) {
+    switch (format) {
+    case PixelFormat::DXT1:
+    case PixelFormat::DXT23:
+    case PixelFormat::DXT45:
+    case PixelFormat::DXN1:
+    case PixelFormat::DXN2SNORM:
+    case PixelFormat::DXN2UNORM:
+    case PixelFormat::BC7U:
+    case PixelFormat::BC6H_UF16:
+    case PixelFormat::BC6H_SF16:
+    case PixelFormat::DXT1_SRGB:
+    case PixelFormat::DXT23_SRGB:
+    case PixelFormat::DXT45_SRGB:
+    case PixelFormat::BC7U_SRGB:
+        return true;
+    }
+    return false;
 }
 
 template <bool morton_to_gl, PixelFormat format>
 void MortonCopy(u32 stride, u32 block_height, u32 height, u32 block_depth, u32 depth, u8* gl_buffer,
                 std::size_t gl_buffer_size, VAddr addr) {
-    constexpr u32 bytes_per_pixel = GetBytesPerPixel(format);
+    constexpr u32 bytes_per_pixel = SurfaceParams::GetBytesPerPixel(format);
 
     // With the BCn formats (DXT and DXN), each 4x4 tile is swizzled instead of just individual
     // pixel values.
-    const u32 tile_size_x{GetDefaultBlockWidth(format)};
-    const u32 tile_size_y{GetDefaultBlockHeight(format)};
+    const u32 tile_size{IsFormatBCn(format) ? 4U : 1U};
 
     if (morton_to_gl) {
-        const std::vector<u8> data =
-            Tegra::Texture::UnswizzleTexture(addr, tile_size_x, tile_size_y, bytes_per_pixel,
-                                             stride, height, depth, block_height, block_depth);
+        const std::vector<u8> data = Tegra::Texture::UnswizzleTexture(
+            addr, tile_size, bytes_per_pixel, stride, height, depth, block_height, block_depth);
         const std::size_t size_to_copy{std::min(gl_buffer_size, data.size())};
         memcpy(gl_buffer, data.data(), size_to_copy);
     } else {
-        Tegra::Texture::CopySwizzledData((stride + tile_size_x - 1) / tile_size_x,
-                                         (height + tile_size_y - 1) / tile_size_y, depth,
+        Tegra::Texture::CopySwizzledData(stride / tile_size, height / tile_size, depth,
                                          bytes_per_pixel, bytes_per_pixel, Memory::GetPointer(addr),
                                          gl_buffer, false, block_height, block_depth);
     }
 }
 
 using GLConversionArray = std::array<void (*)(u32, u32, u32, u32, u32, u8*, std::size_t, VAddr),
-                                     VideoCore::Surface::MaxPixelFormat>;
+                                     SurfaceParams::MaxPixelFormat>;
 
 static constexpr GLConversionArray morton_to_gl_fns = {
     // clang-format off
@@ -453,8 +486,6 @@ static constexpr GLConversionArray morton_to_gl_fns = {
         MortonCopy<true, PixelFormat::ASTC_2D_8X8_SRGB>,
         MortonCopy<true, PixelFormat::ASTC_2D_8X5_SRGB>,
         MortonCopy<true, PixelFormat::ASTC_2D_5X4_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_5X5>,
-        MortonCopy<true, PixelFormat::ASTC_2D_5X5_SRGB>,
         MortonCopy<true, PixelFormat::Z32F>,
         MortonCopy<true, PixelFormat::Z16>,
         MortonCopy<true, PixelFormat::Z24S8>,
@@ -523,8 +554,6 @@ static constexpr GLConversionArray gl_to_morton_fns = {
         nullptr,
         nullptr,
         nullptr,
-        nullptr,
-        nullptr,
         MortonCopy<false, PixelFormat::Z32F>,
         MortonCopy<false, PixelFormat::Z16>,
         MortonCopy<false, PixelFormat::Z24S8>,
@@ -534,39 +563,34 @@ static constexpr GLConversionArray gl_to_morton_fns = {
 };
 
 void SwizzleFunc(const GLConversionArray& functions, const SurfaceParams& params,
-                 std::vector<u8>& gl_buffer, u32 mip_level) {
-    u32 depth = params.MipDepth(mip_level);
-    if (params.target == SurfaceTarget::Texture2D) {
+                 std::vector<u8>& gl_buffer) {
+    u32 depth = params.depth;
+    if (params.target == SurfaceParams::SurfaceTarget::Texture2D) {
         // TODO(Blinkhawk): Eliminate this condition once all texture types are implemented.
         depth = 1U;
     }
     if (params.is_layered) {
-        u64 offset = params.GetMipmapLevelOffset(mip_level);
+        u64 offset = 0;
         u64 offset_gl = 0;
         u64 layer_size = params.LayerMemorySize();
-        u64 gl_size = params.LayerSizeGL(mip_level);
-        for (u32 i = 0; i < params.depth; i++) {
+        u64 gl_size = params.LayerSizeGL();
+        for (u32 i = 0; i < depth; i++) {
             functions[static_cast<std::size_t>(params.pixel_format)](
-                params.MipWidth(mip_level), params.MipBlockHeight(mip_level),
-                params.MipHeight(mip_level), params.MipBlockDepth(mip_level), 1,
+                params.width, params.block_height, params.height, params.block_depth, 1,
                 gl_buffer.data() + offset_gl, gl_size, params.addr + offset);
             offset += layer_size;
             offset_gl += gl_size;
         }
     } else {
-        u64 offset = params.GetMipmapLevelOffset(mip_level);
         functions[static_cast<std::size_t>(params.pixel_format)](
-            params.MipWidth(mip_level), params.MipBlockHeight(mip_level),
-            params.MipHeight(mip_level), params.MipBlockDepth(mip_level), depth, gl_buffer.data(),
-            gl_buffer.size(), params.addr + offset);
+            params.width, params.block_height, params.height, params.block_depth, depth,
+            gl_buffer.data(), gl_buffer.size(), params.addr);
     }
 }
 
-MICROPROFILE_DEFINE(OpenGL_BlitSurface, "OpenGL", "BlitSurface", MP_RGB(128, 192, 64));
 static bool BlitSurface(const Surface& src_surface, const Surface& dst_surface,
                         GLuint read_fb_handle, GLuint draw_fb_handle, GLenum src_attachment = 0,
                         GLenum dst_attachment = 0, std::size_t cubemap_face = 0) {
-    MICROPROFILE_SCOPE(OpenGL_BlitSurface);
 
     const auto& src_params{src_surface->GetSurfaceParams()};
     const auto& dst_params{dst_surface->GetSurfaceParams()};
@@ -585,13 +609,13 @@ static bool BlitSurface(const Surface& src_surface, const Surface& dst_surface,
 
     if (src_params.type == SurfaceType::ColorTexture) {
         switch (src_params.target) {
-        case SurfaceTarget::Texture2D:
+        case SurfaceParams::SurfaceTarget::Texture2D:
             glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + src_attachment,
                                    GL_TEXTURE_2D, src_surface->Texture().handle, 0);
             glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
                                    0, 0);
             break;
-        case SurfaceTarget::TextureCubemap:
+        case SurfaceParams::SurfaceTarget::TextureCubemap:
             glFramebufferTexture2D(
                 GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + src_attachment,
                 static_cast<GLenum>(GL_TEXTURE_CUBE_MAP_POSITIVE_X + cubemap_face),
@@ -600,12 +624,12 @@ static bool BlitSurface(const Surface& src_surface, const Surface& dst_surface,
                 GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
                 static_cast<GLenum>(GL_TEXTURE_CUBE_MAP_POSITIVE_X + cubemap_face), 0, 0);
             break;
-        case SurfaceTarget::Texture2DArray:
+        case SurfaceParams::SurfaceTarget::Texture2DArray:
             glFramebufferTextureLayer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + src_attachment,
                                       src_surface->Texture().handle, 0, 0);
             glFramebufferTextureLayer(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, 0, 0, 0);
             break;
-        case SurfaceTarget::Texture3D:
+        case SurfaceParams::SurfaceTarget::Texture3D:
             glFramebufferTexture3D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + src_attachment,
                                    SurfaceTargetToGL(src_params.target),
                                    src_surface->Texture().handle, 0, 0);
@@ -621,13 +645,13 @@ static bool BlitSurface(const Surface& src_surface, const Surface& dst_surface,
         }
 
         switch (dst_params.target) {
-        case SurfaceTarget::Texture2D:
+        case SurfaceParams::SurfaceTarget::Texture2D:
             glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + dst_attachment,
                                    GL_TEXTURE_2D, dst_surface->Texture().handle, 0);
             glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
                                    0, 0);
             break;
-        case SurfaceTarget::TextureCubemap:
+        case SurfaceParams::SurfaceTarget::TextureCubemap:
             glFramebufferTexture2D(
                 GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + dst_attachment,
                 static_cast<GLenum>(GL_TEXTURE_CUBE_MAP_POSITIVE_X + cubemap_face),
@@ -636,13 +660,13 @@ static bool BlitSurface(const Surface& src_surface, const Surface& dst_surface,
                 GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
                 static_cast<GLenum>(GL_TEXTURE_CUBE_MAP_POSITIVE_X + cubemap_face), 0, 0);
             break;
-        case SurfaceTarget::Texture2DArray:
+        case SurfaceParams::SurfaceTarget::Texture2DArray:
             glFramebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + dst_attachment,
                                       dst_surface->Texture().handle, 0, 0);
             glFramebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, 0, 0, 0);
             break;
 
-        case SurfaceTarget::Texture3D:
+        case SurfaceParams::SurfaceTarget::Texture3D:
             glFramebufferTexture3D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + dst_attachment,
                                    SurfaceTargetToGL(dst_params.target),
                                    dst_surface->Texture().handle, 0, 0);
@@ -706,11 +730,9 @@ static void FastCopySurface(const Surface& src_surface, const Surface& dst_surfa
                        0, 0, width, height, 1);
 }
 
-MICROPROFILE_DEFINE(OpenGL_CopySurface, "OpenGL", "CopySurface", MP_RGB(128, 192, 64));
 static void CopySurface(const Surface& src_surface, const Surface& dst_surface,
                         GLuint copy_pbo_handle, GLenum src_attachment = 0,
                         GLenum dst_attachment = 0, std::size_t cubemap_face = 0) {
-    MICROPROFILE_SCOPE(OpenGL_CopySurface);
     ASSERT_MSG(dst_attachment == 0, "Unimplemented");
 
     const auto& src_params{src_surface->GetSurfaceParams()};
@@ -765,22 +787,21 @@ static void CopySurface(const Surface& src_surface, const Surface& dst_surface,
         UNREACHABLE();
     } else {
         switch (dst_params.target) {
-        case SurfaceTarget::Texture1D:
+        case SurfaceParams::SurfaceTarget::Texture1D:
             glTextureSubImage1D(dst_surface->Texture().handle, 0, 0, width, dest_format.format,
                                 dest_format.type, nullptr);
             break;
-        case SurfaceTarget::Texture2D:
+        case SurfaceParams::SurfaceTarget::Texture2D:
             glTextureSubImage2D(dst_surface->Texture().handle, 0, 0, 0, width, height,
                                 dest_format.format, dest_format.type, nullptr);
             break;
-        case SurfaceTarget::Texture3D:
-        case SurfaceTarget::Texture2DArray:
-        case SurfaceTarget::TextureCubeArray:
+        case SurfaceParams::SurfaceTarget::Texture3D:
+        case SurfaceParams::SurfaceTarget::Texture2DArray:
             glTextureSubImage3D(dst_surface->Texture().handle, 0, 0, 0, 0, width, height,
                                 static_cast<GLsizei>(dst_params.depth), dest_format.format,
                                 dest_format.type, nullptr);
             break;
-        case SurfaceTarget::TextureCubemap:
+        case SurfaceParams::SurfaceTarget::TextureCubemap:
             glTextureSubImage3D(dst_surface->Texture().handle, 0, 0, 0,
                                 static_cast<GLint>(cubemap_face), width, height, 1,
                                 dest_format.format, dest_format.type, nullptr);
@@ -817,43 +838,35 @@ CachedSurface::CachedSurface(const SurfaceParams& params)
     if (!format_tuple.compressed) {
         // Only pre-create the texture for non-compressed textures.
         switch (params.target) {
-        case SurfaceTarget::Texture1D:
-            glTexStorage1D(SurfaceTargetToGL(params.target), params.max_mip_level,
-                           format_tuple.internal_format, rect.GetWidth());
+        case SurfaceParams::SurfaceTarget::Texture1D:
+            glTexStorage1D(SurfaceTargetToGL(params.target), 1, format_tuple.internal_format,
+                           rect.GetWidth());
             break;
-        case SurfaceTarget::Texture2D:
-        case SurfaceTarget::TextureCubemap:
-            glTexStorage2D(SurfaceTargetToGL(params.target), params.max_mip_level,
-                           format_tuple.internal_format, rect.GetWidth(), rect.GetHeight());
+        case SurfaceParams::SurfaceTarget::Texture2D:
+        case SurfaceParams::SurfaceTarget::TextureCubemap:
+            glTexStorage2D(SurfaceTargetToGL(params.target), 1, format_tuple.internal_format,
+                           rect.GetWidth(), rect.GetHeight());
             break;
-        case SurfaceTarget::Texture3D:
-        case SurfaceTarget::Texture2DArray:
-        case SurfaceTarget::TextureCubeArray:
-            glTexStorage3D(SurfaceTargetToGL(params.target), params.max_mip_level,
-                           format_tuple.internal_format, rect.GetWidth(), rect.GetHeight(),
-                           params.depth);
+        case SurfaceParams::SurfaceTarget::Texture3D:
+        case SurfaceParams::SurfaceTarget::Texture2DArray:
+            glTexStorage3D(SurfaceTargetToGL(params.target), 1, format_tuple.internal_format,
+                           rect.GetWidth(), rect.GetHeight(), params.depth);
             break;
         default:
             LOG_CRITICAL(Render_OpenGL, "Unimplemented surface target={}",
                          static_cast<u32>(params.target));
             UNREACHABLE();
-            glTexStorage2D(GL_TEXTURE_2D, params.max_mip_level, format_tuple.internal_format,
-                           rect.GetWidth(), rect.GetHeight());
+            glTexStorage2D(GL_TEXTURE_2D, 1, format_tuple.internal_format, rect.GetWidth(),
+                           rect.GetHeight());
         }
     }
 
     glTexParameteri(SurfaceTargetToGL(params.target), GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(SurfaceTargetToGL(params.target), GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexParameteri(SurfaceTargetToGL(params.target), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(SurfaceTargetToGL(params.target), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glTexParameteri(SurfaceTargetToGL(params.target), GL_TEXTURE_MAX_LEVEL,
-                    params.max_mip_level - 1);
-    if (params.max_mip_level == 1) {
-        glTexParameterf(SurfaceTargetToGL(params.target), GL_TEXTURE_LOD_BIAS, 1000.0);
-    }
 
-    LabelGLObject(GL_TEXTURE, texture.handle, params.addr,
-                  SurfaceParams::SurfaceTargetName(params.target));
+    VideoCore::LabelGLObject(GL_TEXTURE, texture.handle, params.addr,
+                             SurfaceParams::SurfaceTargetName(params.target));
 
     // Clamp size to mapped GPU memory region
     // TODO(bunnei): Super Mario Odyssey maps a 0x40000 byte region and then uses it for a 0x80000
@@ -883,7 +896,7 @@ static void ConvertS8Z24ToZ24S8(std::vector<u8>& data, u32 width, u32 height, bo
 
     S8Z24 s8z24_pixel{};
     Z24S8 z24s8_pixel{};
-    constexpr auto bpp{GetBytesPerPixel(PixelFormat::S8Z24)};
+    constexpr auto bpp{SurfaceParams::GetBytesPerPixel(PixelFormat::S8Z24)};
     for (std::size_t y = 0; y < height; ++y) {
         for (std::size_t x = 0; x < width; ++x) {
             const std::size_t offset{bpp * (y * width + x)};
@@ -903,7 +916,7 @@ static void ConvertS8Z24ToZ24S8(std::vector<u8>& data, u32 width, u32 height, bo
 }
 
 static void ConvertG8R8ToR8G8(std::vector<u8>& data, u32 width, u32 height) {
-    constexpr auto bpp{GetBytesPerPixel(PixelFormat::G8R8U)};
+    constexpr auto bpp{SurfaceParams::GetBytesPerPixel(PixelFormat::G8R8U)};
     for (std::size_t y = 0; y < height; ++y) {
         for (std::size_t x = 0; x < width; ++x) {
             const std::size_t offset{bpp * (y * width + x)};
@@ -920,24 +933,21 @@ static void ConvertG8R8ToR8G8(std::vector<u8>& data, u32 width, u32 height) {
  * typical desktop GPUs.
  */
 static void ConvertFormatAsNeeded_LoadGLBuffer(std::vector<u8>& data, PixelFormat pixel_format,
-                                               u32 width, u32 height, u32 depth) {
+                                               u32 width, u32 height) {
     switch (pixel_format) {
     case PixelFormat::ASTC_2D_4X4:
     case PixelFormat::ASTC_2D_8X8:
     case PixelFormat::ASTC_2D_8X5:
     case PixelFormat::ASTC_2D_5X4:
-    case PixelFormat::ASTC_2D_5X5:
     case PixelFormat::ASTC_2D_4X4_SRGB:
     case PixelFormat::ASTC_2D_8X8_SRGB:
     case PixelFormat::ASTC_2D_8X5_SRGB:
-    case PixelFormat::ASTC_2D_5X4_SRGB:
-    case PixelFormat::ASTC_2D_5X5_SRGB: {
+    case PixelFormat::ASTC_2D_5X4_SRGB: {
         // Convert ASTC pixel formats to RGBA8, as most desktop GPUs do not support ASTC.
         u32 block_width{};
         u32 block_height{};
         std::tie(block_width, block_height) = GetASTCBlockSize(pixel_format);
-        data =
-            Tegra::Texture::ASTC::Decompress(data, width, height, depth, block_width, block_height);
+        data = Tegra::Texture::ASTC::Decompress(data, width, height, block_width, block_height);
         break;
     }
     case PixelFormat::S8Z24:
@@ -979,25 +989,23 @@ static void ConvertFormatAsNeeded_FlushGLBuffer(std::vector<u8>& data, PixelForm
     }
 }
 
-MICROPROFILE_DEFINE(OpenGL_SurfaceLoad, "OpenGL", "Surface Load", MP_RGB(128, 192, 64));
+MICROPROFILE_DEFINE(OpenGL_SurfaceLoad, "OpenGL", "Surface Load", MP_RGB(128, 64, 192));
 void CachedSurface::LoadGLBuffer() {
     MICROPROFILE_SCOPE(OpenGL_SurfaceLoad);
-    gl_buffer.resize(params.max_mip_level);
-    for (u32 i = 0; i < params.max_mip_level; i++)
-        gl_buffer[i].resize(params.GetMipmapSizeGL(i));
+
+    gl_buffer.resize(params.size_in_bytes_gl);
     if (params.is_tiled) {
         ASSERT_MSG(params.block_width == 1, "Block width is defined as {} on texture type {}",
                    params.block_width, static_cast<u32>(params.target));
-        for (u32 i = 0; i < params.max_mip_level; i++)
-            SwizzleFunc(morton_to_gl_fns, params, gl_buffer[i], i);
+
+        SwizzleFunc(morton_to_gl_fns, params, gl_buffer);
     } else {
         const auto texture_src_data{Memory::GetPointer(params.addr)};
         const auto texture_src_data_end{texture_src_data + params.size_in_bytes_gl};
-        gl_buffer[0].assign(texture_src_data, texture_src_data_end);
+        gl_buffer.assign(texture_src_data, texture_src_data_end);
     }
-    for (u32 i = 0; i < params.max_mip_level; i++)
-        ConvertFormatAsNeeded_LoadGLBuffer(gl_buffer[i], params.pixel_format, params.MipWidth(i),
-                                           params.MipHeight(i), params.MipDepth(i));
+
+    ConvertFormatAsNeeded_LoadGLBuffer(gl_buffer, params.pixel_format, params.width, params.height);
 }
 
 MICROPROFILE_DEFINE(OpenGL_SurfaceFlush, "OpenGL", "Surface Flush", MP_RGB(128, 192, 64));
@@ -1007,19 +1015,18 @@ void CachedSurface::FlushGLBuffer() {
     ASSERT_MSG(!IsPixelFormatASTC(params.pixel_format), "Unimplemented");
 
     // OpenGL temporary buffer needs to be big enough to store raw texture size
-    gl_buffer.resize(1);
-    gl_buffer[0].resize(GetSizeInBytes());
+    gl_buffer.resize(GetSizeInBytes());
 
     const FormatTuple& tuple = GetFormatTuple(params.pixel_format, params.component_type);
     // Ensure no bad interactions with GL_UNPACK_ALIGNMENT
-    ASSERT(params.width * GetBytesPerPixel(params.pixel_format) % 4 == 0);
+    ASSERT(params.width * SurfaceParams::GetBytesPerPixel(params.pixel_format) % 4 == 0);
     glPixelStorei(GL_PACK_ROW_LENGTH, static_cast<GLint>(params.width));
     ASSERT(!tuple.compressed);
     glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
     glGetTextureImage(texture.handle, 0, tuple.format, tuple.type,
-                      static_cast<GLsizei>(gl_buffer[0].size()), gl_buffer[0].data());
+                      static_cast<GLsizei>(gl_buffer.size()), gl_buffer.data());
     glPixelStorei(GL_PACK_ROW_LENGTH, 0);
-    ConvertFormatAsNeeded_FlushGLBuffer(gl_buffer[0], params.pixel_format, params.width,
+    ConvertFormatAsNeeded_FlushGLBuffer(gl_buffer, params.pixel_format, params.width,
                                         params.height);
     ASSERT(params.type != SurfaceType::Fill);
     const u8* const texture_src_data = Memory::GetPointer(params.addr);
@@ -1028,23 +1035,28 @@ void CachedSurface::FlushGLBuffer() {
         ASSERT_MSG(params.block_width == 1, "Block width is defined as {} on texture type {}",
                    params.block_width, static_cast<u32>(params.target));
 
-        SwizzleFunc(gl_to_morton_fns, params, gl_buffer[0], 0);
+        SwizzleFunc(gl_to_morton_fns, params, gl_buffer);
     } else {
-        std::memcpy(Memory::GetPointer(GetAddr()), gl_buffer[0].data(), GetSizeInBytes());
+        std::memcpy(Memory::GetPointer(GetAddr()), gl_buffer.data(), GetSizeInBytes());
     }
 }
 
-void CachedSurface::UploadGLMipmapTexture(u32 mip_map, GLuint read_fb_handle,
-                                          GLuint draw_fb_handle) {
-    const auto& rect{params.GetRect(mip_map)};
+MICROPROFILE_DEFINE(OpenGL_TextureUL, "OpenGL", "Texture Upload", MP_RGB(128, 64, 192));
+void CachedSurface::UploadGLTexture(GLuint read_fb_handle, GLuint draw_fb_handle) {
+    if (params.type == SurfaceType::Fill)
+        return;
+
+    MICROPROFILE_SCOPE(OpenGL_TextureUL);
+
+    const auto& rect{params.GetRect()};
 
     // Load data from memory to the surface
     const GLint x0 = static_cast<GLint>(rect.left);
     const GLint y0 = static_cast<GLint>(rect.bottom);
     std::size_t buffer_offset =
-        static_cast<std::size_t>(static_cast<std::size_t>(y0) * params.MipWidth(mip_map) +
+        static_cast<std::size_t>(static_cast<std::size_t>(y0) * params.width +
                                  static_cast<std::size_t>(x0)) *
-        GetBytesPerPixel(params.pixel_format);
+        SurfaceParams::GetBytesPerPixel(params.pixel_format);
 
     const FormatTuple& tuple = GetFormatTuple(params.pixel_format, params.component_type);
     const GLuint target_tex = texture.handle;
@@ -1060,118 +1072,88 @@ void CachedSurface::UploadGLMipmapTexture(u32 mip_map, GLuint read_fb_handle,
     cur_state.Apply();
 
     // Ensure no bad interactions with GL_UNPACK_ALIGNMENT
-    ASSERT(params.MipWidth(mip_map) * GetBytesPerPixel(params.pixel_format) % 4 == 0);
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, static_cast<GLint>(params.MipWidth(mip_map)));
+    ASSERT(params.width * SurfaceParams::GetBytesPerPixel(params.pixel_format) % 4 == 0);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, static_cast<GLint>(params.width));
 
-    GLsizei image_size = static_cast<GLsizei>(params.GetMipmapSizeGL(mip_map, false));
     glActiveTexture(GL_TEXTURE0);
     if (tuple.compressed) {
         switch (params.target) {
-        case SurfaceTarget::Texture2D:
-            glCompressedTexImage2D(SurfaceTargetToGL(params.target), mip_map, tuple.internal_format,
-                                   static_cast<GLsizei>(params.MipWidth(mip_map)),
-                                   static_cast<GLsizei>(params.MipHeight(mip_map)), 0, image_size,
-                                   &gl_buffer[mip_map][buffer_offset]);
+        case SurfaceParams::SurfaceTarget::Texture2D:
+            glCompressedTexImage2D(
+                SurfaceTargetToGL(params.target), 0, tuple.internal_format,
+                static_cast<GLsizei>(params.width), static_cast<GLsizei>(params.height), 0,
+                static_cast<GLsizei>(params.size_in_bytes_gl), &gl_buffer[buffer_offset]);
             break;
-        case SurfaceTarget::Texture3D:
-            glCompressedTexImage3D(SurfaceTargetToGL(params.target), mip_map, tuple.internal_format,
-                                   static_cast<GLsizei>(params.MipWidth(mip_map)),
-                                   static_cast<GLsizei>(params.MipHeight(mip_map)),
-                                   static_cast<GLsizei>(params.MipDepth(mip_map)), 0, image_size,
-                                   &gl_buffer[mip_map][buffer_offset]);
+        case SurfaceParams::SurfaceTarget::Texture3D:
+        case SurfaceParams::SurfaceTarget::Texture2DArray:
+            glCompressedTexImage3D(
+                SurfaceTargetToGL(params.target), 0, tuple.internal_format,
+                static_cast<GLsizei>(params.width), static_cast<GLsizei>(params.height),
+                static_cast<GLsizei>(params.depth), 0,
+                static_cast<GLsizei>(params.size_in_bytes_gl), &gl_buffer[buffer_offset]);
             break;
-        case SurfaceTarget::Texture2DArray:
-        case SurfaceTarget::TextureCubeArray:
-            glCompressedTexImage3D(SurfaceTargetToGL(params.target), mip_map, tuple.internal_format,
-                                   static_cast<GLsizei>(params.MipWidth(mip_map)),
-                                   static_cast<GLsizei>(params.MipHeight(mip_map)),
-                                   static_cast<GLsizei>(params.depth), 0, image_size,
-                                   &gl_buffer[mip_map][buffer_offset]);
-            break;
-        case SurfaceTarget::TextureCubemap: {
-            GLsizei layer_size = static_cast<GLsizei>(params.LayerSizeGL(mip_map));
+        case SurfaceParams::SurfaceTarget::TextureCubemap:
             for (std::size_t face = 0; face < params.depth; ++face) {
                 glCompressedTexImage2D(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face),
-                                       mip_map, tuple.internal_format,
-                                       static_cast<GLsizei>(params.MipWidth(mip_map)),
-                                       static_cast<GLsizei>(params.MipHeight(mip_map)), 0,
-                                       layer_size, &gl_buffer[mip_map][buffer_offset]);
-                buffer_offset += layer_size;
+                                       0, tuple.internal_format, static_cast<GLsizei>(params.width),
+                                       static_cast<GLsizei>(params.height), 0,
+                                       static_cast<GLsizei>(params.SizeInBytesCubeFaceGL()),
+                                       &gl_buffer[buffer_offset]);
+                buffer_offset += params.SizeInBytesCubeFace();
             }
             break;
-        }
         default:
             LOG_CRITICAL(Render_OpenGL, "Unimplemented surface target={}",
                          static_cast<u32>(params.target));
             UNREACHABLE();
-            glCompressedTexImage2D(GL_TEXTURE_2D, mip_map, tuple.internal_format,
-                                   static_cast<GLsizei>(params.MipWidth(mip_map)),
-                                   static_cast<GLsizei>(params.MipHeight(mip_map)), 0,
-                                   static_cast<GLsizei>(params.size_in_bytes_gl),
-                                   &gl_buffer[mip_map][buffer_offset]);
+            glCompressedTexImage2D(
+                GL_TEXTURE_2D, 0, tuple.internal_format, static_cast<GLsizei>(params.width),
+                static_cast<GLsizei>(params.height), 0,
+                static_cast<GLsizei>(params.size_in_bytes_gl), &gl_buffer[buffer_offset]);
         }
     } else {
 
         switch (params.target) {
-        case SurfaceTarget::Texture1D:
-            glTexSubImage1D(SurfaceTargetToGL(params.target), mip_map, x0,
+        case SurfaceParams::SurfaceTarget::Texture1D:
+            glTexSubImage1D(SurfaceTargetToGL(params.target), 0, x0,
                             static_cast<GLsizei>(rect.GetWidth()), tuple.format, tuple.type,
-                            &gl_buffer[mip_map][buffer_offset]);
+                            &gl_buffer[buffer_offset]);
             break;
-        case SurfaceTarget::Texture2D:
-            glTexSubImage2D(SurfaceTargetToGL(params.target), mip_map, x0, y0,
+        case SurfaceParams::SurfaceTarget::Texture2D:
+            glTexSubImage2D(SurfaceTargetToGL(params.target), 0, x0, y0,
                             static_cast<GLsizei>(rect.GetWidth()),
                             static_cast<GLsizei>(rect.GetHeight()), tuple.format, tuple.type,
-                            &gl_buffer[mip_map][buffer_offset]);
+                            &gl_buffer[buffer_offset]);
             break;
-        case SurfaceTarget::Texture3D:
-            glTexSubImage3D(SurfaceTargetToGL(params.target), mip_map, x0, y0, 0,
-                            static_cast<GLsizei>(rect.GetWidth()),
-                            static_cast<GLsizei>(rect.GetHeight()), params.MipDepth(mip_map),
-                            tuple.format, tuple.type, &gl_buffer[mip_map][buffer_offset]);
-            break;
-        case SurfaceTarget::Texture2DArray:
-        case SurfaceTarget::TextureCubeArray:
-            glTexSubImage3D(SurfaceTargetToGL(params.target), mip_map, x0, y0, 0,
+        case SurfaceParams::SurfaceTarget::Texture3D:
+        case SurfaceParams::SurfaceTarget::Texture2DArray:
+            glTexSubImage3D(SurfaceTargetToGL(params.target), 0, x0, y0, 0,
                             static_cast<GLsizei>(rect.GetWidth()),
                             static_cast<GLsizei>(rect.GetHeight()), params.depth, tuple.format,
-                            tuple.type, &gl_buffer[mip_map][buffer_offset]);
+                            tuple.type, &gl_buffer[buffer_offset]);
             break;
-        case SurfaceTarget::TextureCubemap: {
-            std::size_t start = buffer_offset;
+        case SurfaceParams::SurfaceTarget::TextureCubemap:
             for (std::size_t face = 0; face < params.depth; ++face) {
-                glTexSubImage2D(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face), mip_map,
-                                x0, y0, static_cast<GLsizei>(rect.GetWidth()),
+                glTexSubImage2D(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face), 0, x0,
+                                y0, static_cast<GLsizei>(rect.GetWidth()),
                                 static_cast<GLsizei>(rect.GetHeight()), tuple.format, tuple.type,
-                                &gl_buffer[mip_map][buffer_offset]);
-                buffer_offset += params.LayerSizeGL(mip_map);
+                                &gl_buffer[buffer_offset]);
+                buffer_offset += params.SizeInBytesCubeFace();
             }
             break;
-        }
         default:
             LOG_CRITICAL(Render_OpenGL, "Unimplemented surface target={}",
                          static_cast<u32>(params.target));
             UNREACHABLE();
-            glTexSubImage2D(GL_TEXTURE_2D, mip_map, x0, y0, static_cast<GLsizei>(rect.GetWidth()),
+            glTexSubImage2D(GL_TEXTURE_2D, 0, x0, y0, static_cast<GLsizei>(rect.GetWidth()),
                             static_cast<GLsizei>(rect.GetHeight()), tuple.format, tuple.type,
-                            &gl_buffer[mip_map][buffer_offset]);
+                            &gl_buffer[buffer_offset]);
         }
     }
 
     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
 }
 
-MICROPROFILE_DEFINE(OpenGL_TextureUL, "OpenGL", "Texture Upload", MP_RGB(128, 192, 64));
-void CachedSurface::UploadGLTexture(GLuint read_fb_handle, GLuint draw_fb_handle) {
-    if (params.type == SurfaceType::Fill)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_TextureUL);
-
-    for (u32 i = 0; i < params.max_mip_level; i++)
-        UploadGLMipmapTexture(i, read_fb_handle, draw_fb_handle);
-}
-
 RasterizerCacheOpenGL::RasterizerCacheOpenGL() {
     read_framebuffer.Create();
     draw_framebuffer.Create();
@@ -1312,7 +1294,8 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
     // For compatible surfaces, we can just do fast glCopyImageSubData based copy
     if (old_params.target == new_params.target && old_params.type == new_params.type &&
         old_params.depth == new_params.depth && old_params.depth == 1 &&
-        GetFormatBpp(old_params.pixel_format) == GetFormatBpp(new_params.pixel_format)) {
+        SurfaceParams::GetFormatBpp(old_params.pixel_format) ==
+            SurfaceParams::GetFormatBpp(new_params.pixel_format)) {
         FastCopySurface(old_surface, new_surface);
         return new_surface;
     }
@@ -1325,16 +1308,15 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
     const bool is_blit{old_params.pixel_format == new_params.pixel_format};
 
     switch (new_params.target) {
-    case SurfaceTarget::Texture2D:
+    case SurfaceParams::SurfaceTarget::Texture2D:
         if (is_blit) {
             BlitSurface(old_surface, new_surface, read_framebuffer.handle, draw_framebuffer.handle);
         } else {
             CopySurface(old_surface, new_surface, copy_pbo.handle);
         }
         break;
-    case SurfaceTarget::TextureCubemap:
-    case SurfaceTarget::Texture3D:
-    case SurfaceTarget::TextureCubeArray:
+    case SurfaceParams::SurfaceTarget::TextureCubemap:
+    case SurfaceParams::SurfaceTarget::Texture3D:
         AccurateCopySurface(old_surface, new_surface);
         break;
     default:
@@ -1344,7 +1326,7 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
     }
 
     return new_surface;
-}
+} // namespace OpenGL
 
 Surface RasterizerCacheOpenGL::TryFindFramebufferSurface(VAddr addr) const {
     return TryGet(addr);

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -7,7 +7,6 @@
 #include <array>
 #include <map>
 #include <memory>
-#include <string>
 #include <vector>
 
 #include "common/alignment.h"
@@ -19,7 +18,6 @@
 #include "video_core/rasterizer_cache.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/gl_shader_gen.h"
-#include "video_core/surface.h"
 #include "video_core/textures/decoders.h"
 #include "video_core/textures/texture.h"
 
@@ -29,12 +27,135 @@ class CachedSurface;
 using Surface = std::shared_ptr<CachedSurface>;
 using SurfaceSurfaceRect_Tuple = std::tuple<Surface, Surface, MathUtil::Rectangle<u32>>;
 
-using SurfaceTarget = VideoCore::Surface::SurfaceTarget;
-using SurfaceType = VideoCore::Surface::SurfaceType;
-using PixelFormat = VideoCore::Surface::PixelFormat;
-using ComponentType = VideoCore::Surface::ComponentType;
-
 struct SurfaceParams {
+    enum class PixelFormat {
+        ABGR8U = 0,
+        ABGR8S = 1,
+        ABGR8UI = 2,
+        B5G6R5U = 3,
+        A2B10G10R10U = 4,
+        A1B5G5R5U = 5,
+        R8U = 6,
+        R8UI = 7,
+        RGBA16F = 8,
+        RGBA16U = 9,
+        RGBA16UI = 10,
+        R11FG11FB10F = 11,
+        RGBA32UI = 12,
+        DXT1 = 13,
+        DXT23 = 14,
+        DXT45 = 15,
+        DXN1 = 16, // This is also known as BC4
+        DXN2UNORM = 17,
+        DXN2SNORM = 18,
+        BC7U = 19,
+        BC6H_UF16 = 20,
+        BC6H_SF16 = 21,
+        ASTC_2D_4X4 = 22,
+        G8R8U = 23,
+        G8R8S = 24,
+        BGRA8 = 25,
+        RGBA32F = 26,
+        RG32F = 27,
+        R32F = 28,
+        R16F = 29,
+        R16U = 30,
+        R16S = 31,
+        R16UI = 32,
+        R16I = 33,
+        RG16 = 34,
+        RG16F = 35,
+        RG16UI = 36,
+        RG16I = 37,
+        RG16S = 38,
+        RGB32F = 39,
+        RGBA8_SRGB = 40,
+        RG8U = 41,
+        RG8S = 42,
+        RG32UI = 43,
+        R32UI = 44,
+        ASTC_2D_8X8 = 45,
+        ASTC_2D_8X5 = 46,
+        ASTC_2D_5X4 = 47,
+        BGRA8_SRGB = 48,
+        DXT1_SRGB = 49,
+        DXT23_SRGB = 50,
+        DXT45_SRGB = 51,
+        BC7U_SRGB = 52,
+        ASTC_2D_4X4_SRGB = 53,
+        ASTC_2D_8X8_SRGB = 54,
+        ASTC_2D_8X5_SRGB = 55,
+        ASTC_2D_5X4_SRGB = 56,
+
+        MaxColorFormat,
+
+        // Depth formats
+        Z32F = 57,
+        Z16 = 58,
+
+        MaxDepthFormat,
+
+        // DepthStencil formats
+        Z24S8 = 59,
+        S8Z24 = 60,
+        Z32FS8 = 61,
+
+        MaxDepthStencilFormat,
+
+        Max = MaxDepthStencilFormat,
+        Invalid = 255,
+    };
+
+    static constexpr std::size_t MaxPixelFormat = static_cast<std::size_t>(PixelFormat::Max);
+
+    enum class ComponentType {
+        Invalid = 0,
+        SNorm = 1,
+        UNorm = 2,
+        SInt = 3,
+        UInt = 4,
+        Float = 5,
+    };
+
+    enum class SurfaceType {
+        ColorTexture = 0,
+        Depth = 1,
+        DepthStencil = 2,
+        Fill = 3,
+        Invalid = 4,
+    };
+
+    enum class SurfaceTarget {
+        Texture1D,
+        Texture2D,
+        Texture3D,
+        Texture1DArray,
+        Texture2DArray,
+        TextureCubemap,
+    };
+
+    static SurfaceTarget SurfaceTargetFromTextureType(Tegra::Texture::TextureType texture_type) {
+        switch (texture_type) {
+        case Tegra::Texture::TextureType::Texture1D:
+            return SurfaceTarget::Texture1D;
+        case Tegra::Texture::TextureType::Texture2D:
+        case Tegra::Texture::TextureType::Texture2DNoMipmap:
+            return SurfaceTarget::Texture2D;
+        case Tegra::Texture::TextureType::Texture3D:
+            return SurfaceTarget::Texture3D;
+        case Tegra::Texture::TextureType::TextureCubemap:
+            return SurfaceTarget::TextureCubemap;
+        case Tegra::Texture::TextureType::Texture1DArray:
+            return SurfaceTarget::Texture1DArray;
+        case Tegra::Texture::TextureType::Texture2DArray:
+            return SurfaceTarget::Texture2DArray;
+        default:
+            LOG_CRITICAL(HW_GPU, "Unimplemented texture_type={}", static_cast<u32>(texture_type));
+            UNREACHABLE();
+            return SurfaceTarget::Texture2D;
+        }
+    }
+
     static std::string SurfaceTargetName(SurfaceTarget target) {
         switch (target) {
         case SurfaceTarget::Texture1D:
@@ -49,8 +170,6 @@ struct SurfaceParams {
             return "Texture2DArray";
         case SurfaceTarget::TextureCubemap:
             return "TextureCubemap";
-        case SurfaceTarget::TextureCubeArray:
-            return "TextureCubeArray";
         default:
             LOG_CRITICAL(HW_GPU, "Unimplemented surface_target={}", static_cast<u32>(target));
             UNREACHABLE();
@@ -58,12 +177,664 @@ struct SurfaceParams {
         }
     }
 
+    static bool SurfaceTargetIsLayered(SurfaceTarget target) {
+        switch (target) {
+        case SurfaceTarget::Texture1D:
+        case SurfaceTarget::Texture2D:
+        case SurfaceTarget::Texture3D:
+            return false;
+        case SurfaceTarget::Texture1DArray:
+        case SurfaceTarget::Texture2DArray:
+        case SurfaceTarget::TextureCubemap:
+            return true;
+        default:
+            LOG_CRITICAL(HW_GPU, "Unimplemented surface_target={}", static_cast<u32>(target));
+            UNREACHABLE();
+            return false;
+        }
+    }
+
+    /**
+     * Gets the compression factor for the specified PixelFormat. This applies to just the
+     * "compressed width" and "compressed height", not the overall compression factor of a
+     * compressed image. This is used for maintaining proper surface sizes for compressed
+     * texture formats.
+     */
+    static constexpr u32 GetCompressionFactor(PixelFormat format) {
+        if (format == PixelFormat::Invalid)
+            return 0;
+
+        constexpr std::array<u32, MaxPixelFormat> compression_factor_table = {{
+            1, // ABGR8U
+            1, // ABGR8S
+            1, // ABGR8UI
+            1, // B5G6R5U
+            1, // A2B10G10R10U
+            1, // A1B5G5R5U
+            1, // R8U
+            1, // R8UI
+            1, // RGBA16F
+            1, // RGBA16U
+            1, // RGBA16UI
+            1, // R11FG11FB10F
+            1, // RGBA32UI
+            4, // DXT1
+            4, // DXT23
+            4, // DXT45
+            4, // DXN1
+            4, // DXN2UNORM
+            4, // DXN2SNORM
+            4, // BC7U
+            4, // BC6H_UF16
+            4, // BC6H_SF16
+            4, // ASTC_2D_4X4
+            1, // G8R8U
+            1, // G8R8S
+            1, // BGRA8
+            1, // RGBA32F
+            1, // RG32F
+            1, // R32F
+            1, // R16F
+            1, // R16U
+            1, // R16S
+            1, // R16UI
+            1, // R16I
+            1, // RG16
+            1, // RG16F
+            1, // RG16UI
+            1, // RG16I
+            1, // RG16S
+            1, // RGB32F
+            1, // RGBA8_SRGB
+            1, // RG8U
+            1, // RG8S
+            1, // RG32UI
+            1, // R32UI
+            4, // ASTC_2D_8X8
+            4, // ASTC_2D_8X5
+            4, // ASTC_2D_5X4
+            1, // BGRA8_SRGB
+            4, // DXT1_SRGB
+            4, // DXT23_SRGB
+            4, // DXT45_SRGB
+            4, // BC7U_SRGB
+            4, // ASTC_2D_4X4_SRGB
+            4, // ASTC_2D_8X8_SRGB
+            4, // ASTC_2D_8X5_SRGB
+            4, // ASTC_2D_5X4_SRGB
+            1, // Z32F
+            1, // Z16
+            1, // Z24S8
+            1, // S8Z24
+            1, // Z32FS8
+        }};
+
+        ASSERT(static_cast<std::size_t>(format) < compression_factor_table.size());
+        return compression_factor_table[static_cast<std::size_t>(format)];
+    }
+
+    static constexpr u32 GetDefaultBlockHeight(PixelFormat format) {
+        if (format == PixelFormat::Invalid)
+            return 0;
+        constexpr std::array<u32, MaxPixelFormat> block_height_table = {{
+            1, // ABGR8U
+            1, // ABGR8S
+            1, // ABGR8UI
+            1, // B5G6R5U
+            1, // A2B10G10R10U
+            1, // A1B5G5R5U
+            1, // R8U
+            1, // R8UI
+            1, // RGBA16F
+            1, // RGBA16U
+            1, // RGBA16UI
+            1, // R11FG11FB10F
+            1, // RGBA32UI
+            4, // DXT1
+            4, // DXT23
+            4, // DXT45
+            4, // DXN1
+            4, // DXN2UNORM
+            4, // DXN2SNORM
+            4, // BC7U
+            4, // BC6H_UF16
+            4, // BC6H_SF16
+            4, // ASTC_2D_4X4
+            1, // G8R8U
+            1, // G8R8S
+            1, // BGRA8
+            1, // RGBA32F
+            1, // RG32F
+            1, // R32F
+            1, // R16F
+            1, // R16U
+            1, // R16S
+            1, // R16UI
+            1, // R16I
+            1, // RG16
+            1, // RG16F
+            1, // RG16UI
+            1, // RG16I
+            1, // RG16S
+            1, // RGB32F
+            1, // RGBA8_SRGB
+            1, // RG8U
+            1, // RG8S
+            1, // RG32UI
+            1, // R32UI
+            8, // ASTC_2D_8X8
+            5, // ASTC_2D_8X5
+            4, // ASTC_2D_5X4
+            1, // BGRA8_SRGB
+            4, // DXT1_SRGB
+            4, // DXT23_SRGB
+            4, // DXT45_SRGB
+            4, // BC7U_SRGB
+            4, // ASTC_2D_4X4_SRGB
+            8, // ASTC_2D_8X8_SRGB
+            5, // ASTC_2D_8X5_SRGB
+            4, // ASTC_2D_5X4_SRGB
+            1, // Z32F
+            1, // Z16
+            1, // Z24S8
+            1, // S8Z24
+            1, // Z32FS8
+        }};
+        ASSERT(static_cast<std::size_t>(format) < block_height_table.size());
+        return block_height_table[static_cast<std::size_t>(format)];
+    }
+
+    static constexpr u32 GetFormatBpp(PixelFormat format) {
+        if (format == PixelFormat::Invalid)
+            return 0;
+
+        constexpr std::array<u32, MaxPixelFormat> bpp_table = {{
+            32,  // ABGR8U
+            32,  // ABGR8S
+            32,  // ABGR8UI
+            16,  // B5G6R5U
+            32,  // A2B10G10R10U
+            16,  // A1B5G5R5U
+            8,   // R8U
+            8,   // R8UI
+            64,  // RGBA16F
+            64,  // RGBA16U
+            64,  // RGBA16UI
+            32,  // R11FG11FB10F
+            128, // RGBA32UI
+            64,  // DXT1
+            128, // DXT23
+            128, // DXT45
+            64,  // DXN1
+            128, // DXN2UNORM
+            128, // DXN2SNORM
+            128, // BC7U
+            128, // BC6H_UF16
+            128, // BC6H_SF16
+            32,  // ASTC_2D_4X4
+            16,  // G8R8U
+            16,  // G8R8S
+            32,  // BGRA8
+            128, // RGBA32F
+            64,  // RG32F
+            32,  // R32F
+            16,  // R16F
+            16,  // R16U
+            16,  // R16S
+            16,  // R16UI
+            16,  // R16I
+            32,  // RG16
+            32,  // RG16F
+            32,  // RG16UI
+            32,  // RG16I
+            32,  // RG16S
+            96,  // RGB32F
+            32,  // RGBA8_SRGB
+            16,  // RG8U
+            16,  // RG8S
+            64,  // RG32UI
+            32,  // R32UI
+            16,  // ASTC_2D_8X8
+            32,  // ASTC_2D_8X5
+            32,  // ASTC_2D_5X4
+            32,  // BGRA8_SRGB
+            64,  // DXT1_SRGB
+            128, // DXT23_SRGB
+            128, // DXT45_SRGB
+            128, // BC7U
+            32,  // ASTC_2D_4X4_SRGB
+            16,  // ASTC_2D_8X8_SRGB
+            32,  // ASTC_2D_8X5_SRGB
+            32,  // ASTC_2D_5X4_SRGB
+            32,  // Z32F
+            16,  // Z16
+            32,  // Z24S8
+            32,  // S8Z24
+            64,  // Z32FS8
+        }};
+
+        ASSERT(static_cast<std::size_t>(format) < bpp_table.size());
+        return bpp_table[static_cast<std::size_t>(format)];
+    }
+
     u32 GetFormatBpp() const {
-        return VideoCore::Surface::GetFormatBpp(pixel_format);
+        return GetFormatBpp(pixel_format);
+    }
+
+    static PixelFormat PixelFormatFromDepthFormat(Tegra::DepthFormat format) {
+        switch (format) {
+        case Tegra::DepthFormat::S8_Z24_UNORM:
+            return PixelFormat::S8Z24;
+        case Tegra::DepthFormat::Z24_S8_UNORM:
+            return PixelFormat::Z24S8;
+        case Tegra::DepthFormat::Z32_FLOAT:
+            return PixelFormat::Z32F;
+        case Tegra::DepthFormat::Z16_UNORM:
+            return PixelFormat::Z16;
+        case Tegra::DepthFormat::Z32_S8_X24_FLOAT:
+            return PixelFormat::Z32FS8;
+        default:
+            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
+            UNREACHABLE();
+        }
+    }
+
+    static PixelFormat PixelFormatFromRenderTargetFormat(Tegra::RenderTargetFormat format) {
+        switch (format) {
+        // TODO (Hexagon12): Converting SRGBA to RGBA is a hack and doesn't completely correct the
+        // gamma.
+        case Tegra::RenderTargetFormat::RGBA8_SRGB:
+            return PixelFormat::RGBA8_SRGB;
+        case Tegra::RenderTargetFormat::RGBA8_UNORM:
+            return PixelFormat::ABGR8U;
+        case Tegra::RenderTargetFormat::RGBA8_SNORM:
+            return PixelFormat::ABGR8S;
+        case Tegra::RenderTargetFormat::RGBA8_UINT:
+            return PixelFormat::ABGR8UI;
+        case Tegra::RenderTargetFormat::BGRA8_SRGB:
+            return PixelFormat::BGRA8_SRGB;
+        case Tegra::RenderTargetFormat::BGRA8_UNORM:
+            return PixelFormat::BGRA8;
+        case Tegra::RenderTargetFormat::RGB10_A2_UNORM:
+            return PixelFormat::A2B10G10R10U;
+        case Tegra::RenderTargetFormat::RGBA16_FLOAT:
+            return PixelFormat::RGBA16F;
+        case Tegra::RenderTargetFormat::RGBA16_UNORM:
+            return PixelFormat::RGBA16U;
+        case Tegra::RenderTargetFormat::RGBA16_UINT:
+            return PixelFormat::RGBA16UI;
+        case Tegra::RenderTargetFormat::RGBA32_FLOAT:
+            return PixelFormat::RGBA32F;
+        case Tegra::RenderTargetFormat::RG32_FLOAT:
+            return PixelFormat::RG32F;
+        case Tegra::RenderTargetFormat::R11G11B10_FLOAT:
+            return PixelFormat::R11FG11FB10F;
+        case Tegra::RenderTargetFormat::B5G6R5_UNORM:
+            return PixelFormat::B5G6R5U;
+        case Tegra::RenderTargetFormat::BGR5A1_UNORM:
+            return PixelFormat::A1B5G5R5U;
+        case Tegra::RenderTargetFormat::RGBA32_UINT:
+            return PixelFormat::RGBA32UI;
+        case Tegra::RenderTargetFormat::R8_UNORM:
+            return PixelFormat::R8U;
+        case Tegra::RenderTargetFormat::R8_UINT:
+            return PixelFormat::R8UI;
+        case Tegra::RenderTargetFormat::RG16_FLOAT:
+            return PixelFormat::RG16F;
+        case Tegra::RenderTargetFormat::RG16_UINT:
+            return PixelFormat::RG16UI;
+        case Tegra::RenderTargetFormat::RG16_SINT:
+            return PixelFormat::RG16I;
+        case Tegra::RenderTargetFormat::RG16_UNORM:
+            return PixelFormat::RG16;
+        case Tegra::RenderTargetFormat::RG16_SNORM:
+            return PixelFormat::RG16S;
+        case Tegra::RenderTargetFormat::RG8_UNORM:
+            return PixelFormat::RG8U;
+        case Tegra::RenderTargetFormat::RG8_SNORM:
+            return PixelFormat::RG8S;
+        case Tegra::RenderTargetFormat::R16_FLOAT:
+            return PixelFormat::R16F;
+        case Tegra::RenderTargetFormat::R16_UNORM:
+            return PixelFormat::R16U;
+        case Tegra::RenderTargetFormat::R16_SNORM:
+            return PixelFormat::R16S;
+        case Tegra::RenderTargetFormat::R16_UINT:
+            return PixelFormat::R16UI;
+        case Tegra::RenderTargetFormat::R16_SINT:
+            return PixelFormat::R16I;
+        case Tegra::RenderTargetFormat::R32_FLOAT:
+            return PixelFormat::R32F;
+        case Tegra::RenderTargetFormat::R32_UINT:
+            return PixelFormat::R32UI;
+        case Tegra::RenderTargetFormat::RG32_UINT:
+            return PixelFormat::RG32UI;
+        default:
+            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
+            UNREACHABLE();
+        }
+    }
+
+    static PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
+                                                    Tegra::Texture::ComponentType component_type,
+                                                    bool is_srgb) {
+        // TODO(Subv): Properly implement this
+        switch (format) {
+        case Tegra::Texture::TextureFormat::A8R8G8B8:
+            if (is_srgb) {
+                return PixelFormat::RGBA8_SRGB;
+            }
+            switch (component_type) {
+            case Tegra::Texture::ComponentType::UNORM:
+                return PixelFormat::ABGR8U;
+            case Tegra::Texture::ComponentType::SNORM:
+                return PixelFormat::ABGR8S;
+            case Tegra::Texture::ComponentType::UINT:
+                return PixelFormat::ABGR8UI;
+            }
+            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
+                         static_cast<u32>(component_type));
+            UNREACHABLE();
+        case Tegra::Texture::TextureFormat::B5G6R5:
+            switch (component_type) {
+            case Tegra::Texture::ComponentType::UNORM:
+                return PixelFormat::B5G6R5U;
+            }
+            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
+                         static_cast<u32>(component_type));
+            UNREACHABLE();
+        case Tegra::Texture::TextureFormat::A2B10G10R10:
+            switch (component_type) {
+            case Tegra::Texture::ComponentType::UNORM:
+                return PixelFormat::A2B10G10R10U;
+            }
+            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
+                         static_cast<u32>(component_type));
+            UNREACHABLE();
+        case Tegra::Texture::TextureFormat::A1B5G5R5:
+            switch (component_type) {
+            case Tegra::Texture::ComponentType::UNORM:
+                return PixelFormat::A1B5G5R5U;
+            }
+            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
+                         static_cast<u32>(component_type));
+            UNREACHABLE();
+        case Tegra::Texture::TextureFormat::R8:
+            switch (component_type) {
+            case Tegra::Texture::ComponentType::UNORM:
+                return PixelFormat::R8U;
+            case Tegra::Texture::ComponentType::UINT:
+                return PixelFormat::R8UI;
+            }
+            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
+                         static_cast<u32>(component_type));
+            UNREACHABLE();
+        case Tegra::Texture::TextureFormat::G8R8:
+            switch (component_type) {
+            case Tegra::Texture::ComponentType::UNORM:
+                return PixelFormat::G8R8U;
+            case Tegra::Texture::ComponentType::SNORM:
+                return PixelFormat::G8R8S;
+            }
+            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
+                         static_cast<u32>(component_type));
+            UNREACHABLE();
+        case Tegra::Texture::TextureFormat::R16_G16_B16_A16:
+            switch (component_type) {
+            case Tegra::Texture::ComponentType::UNORM:
+                return PixelFormat::RGBA16U;
+            case Tegra::Texture::ComponentType::FLOAT:
+                return PixelFormat::RGBA16F;
+            }
+            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
+                         static_cast<u32>(component_type));
+            UNREACHABLE();
+        case Tegra::Texture::TextureFormat::BF10GF11RF11:
+            switch (component_type) {
+            case Tegra::Texture::ComponentType::FLOAT:
+                return PixelFormat::R11FG11FB10F;
+            }
+            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
+                         static_cast<u32>(component_type));
+            UNREACHABLE();
+        case Tegra::Texture::TextureFormat::R32_G32_B32_A32:
+            switch (component_type) {
+            case Tegra::Texture::ComponentType::FLOAT:
+                return PixelFormat::RGBA32F;
+            case Tegra::Texture::ComponentType::UINT:
+                return PixelFormat::RGBA32UI;
+            }
+            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
+                         static_cast<u32>(component_type));
+            UNREACHABLE();
+        case Tegra::Texture::TextureFormat::R32_G32:
+            switch (component_type) {
+            case Tegra::Texture::ComponentType::FLOAT:
+                return PixelFormat::RG32F;
+            case Tegra::Texture::ComponentType::UINT:
+                return PixelFormat::RG32UI;
+            }
+            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
+                         static_cast<u32>(component_type));
+            UNREACHABLE();
+        case Tegra::Texture::TextureFormat::R32_G32_B32:
+            switch (component_type) {
+            case Tegra::Texture::ComponentType::FLOAT:
+                return PixelFormat::RGB32F;
+            }
+            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
+                         static_cast<u32>(component_type));
+            UNREACHABLE();
+        case Tegra::Texture::TextureFormat::R16:
+            switch (component_type) {
+            case Tegra::Texture::ComponentType::FLOAT:
+                return PixelFormat::R16F;
+            case Tegra::Texture::ComponentType::UNORM:
+                return PixelFormat::R16U;
+            case Tegra::Texture::ComponentType::SNORM:
+                return PixelFormat::R16S;
+            case Tegra::Texture::ComponentType::UINT:
+                return PixelFormat::R16UI;
+            case Tegra::Texture::ComponentType::SINT:
+                return PixelFormat::R16I;
+            }
+            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
+                         static_cast<u32>(component_type));
+            UNREACHABLE();
+        case Tegra::Texture::TextureFormat::R32:
+            switch (component_type) {
+            case Tegra::Texture::ComponentType::FLOAT:
+                return PixelFormat::R32F;
+            case Tegra::Texture::ComponentType::UINT:
+                return PixelFormat::R32UI;
+            }
+            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
+                         static_cast<u32>(component_type));
+            UNREACHABLE();
+        case Tegra::Texture::TextureFormat::ZF32:
+            return PixelFormat::Z32F;
+        case Tegra::Texture::TextureFormat::Z16:
+            return PixelFormat::Z16;
+        case Tegra::Texture::TextureFormat::Z24S8:
+            return PixelFormat::Z24S8;
+        case Tegra::Texture::TextureFormat::DXT1:
+            return is_srgb ? PixelFormat::DXT1_SRGB : PixelFormat::DXT1;
+        case Tegra::Texture::TextureFormat::DXT23:
+            return is_srgb ? PixelFormat::DXT23_SRGB : PixelFormat::DXT23;
+        case Tegra::Texture::TextureFormat::DXT45:
+            return is_srgb ? PixelFormat::DXT45_SRGB : PixelFormat::DXT45;
+        case Tegra::Texture::TextureFormat::DXN1:
+            return PixelFormat::DXN1;
+        case Tegra::Texture::TextureFormat::DXN2:
+            switch (component_type) {
+            case Tegra::Texture::ComponentType::UNORM:
+                return PixelFormat::DXN2UNORM;
+            case Tegra::Texture::ComponentType::SNORM:
+                return PixelFormat::DXN2SNORM;
+            }
+            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
+                         static_cast<u32>(component_type));
+            UNREACHABLE();
+        case Tegra::Texture::TextureFormat::BC7U:
+            return is_srgb ? PixelFormat::BC7U_SRGB : PixelFormat::BC7U;
+        case Tegra::Texture::TextureFormat::BC6H_UF16:
+            return PixelFormat::BC6H_UF16;
+        case Tegra::Texture::TextureFormat::BC6H_SF16:
+            return PixelFormat::BC6H_SF16;
+        case Tegra::Texture::TextureFormat::ASTC_2D_4X4:
+            return is_srgb ? PixelFormat::ASTC_2D_4X4_SRGB : PixelFormat::ASTC_2D_4X4;
+        case Tegra::Texture::TextureFormat::ASTC_2D_5X4:
+            return is_srgb ? PixelFormat::ASTC_2D_5X4_SRGB : PixelFormat::ASTC_2D_5X4;
+        case Tegra::Texture::TextureFormat::ASTC_2D_8X8:
+            return is_srgb ? PixelFormat::ASTC_2D_8X8_SRGB : PixelFormat::ASTC_2D_8X8;
+        case Tegra::Texture::TextureFormat::ASTC_2D_8X5:
+            return is_srgb ? PixelFormat::ASTC_2D_8X5_SRGB : PixelFormat::ASTC_2D_8X5;
+        case Tegra::Texture::TextureFormat::R16_G16:
+            switch (component_type) {
+            case Tegra::Texture::ComponentType::FLOAT:
+                return PixelFormat::RG16F;
+            case Tegra::Texture::ComponentType::UNORM:
+                return PixelFormat::RG16;
+            case Tegra::Texture::ComponentType::SNORM:
+                return PixelFormat::RG16S;
+            case Tegra::Texture::ComponentType::UINT:
+                return PixelFormat::RG16UI;
+            case Tegra::Texture::ComponentType::SINT:
+                return PixelFormat::RG16I;
+            }
+            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
+                         static_cast<u32>(component_type));
+            UNREACHABLE();
+        default:
+            LOG_CRITICAL(HW_GPU, "Unimplemented format={}, component_type={}",
+                         static_cast<u32>(format), static_cast<u32>(component_type));
+            UNREACHABLE();
+        }
+    }
+
+    static ComponentType ComponentTypeFromTexture(Tegra::Texture::ComponentType type) {
+        // TODO(Subv): Implement more component types
+        switch (type) {
+        case Tegra::Texture::ComponentType::UNORM:
+            return ComponentType::UNorm;
+        case Tegra::Texture::ComponentType::FLOAT:
+            return ComponentType::Float;
+        case Tegra::Texture::ComponentType::SNORM:
+            return ComponentType::SNorm;
+        case Tegra::Texture::ComponentType::UINT:
+            return ComponentType::UInt;
+        case Tegra::Texture::ComponentType::SINT:
+            return ComponentType::SInt;
+        default:
+            LOG_CRITICAL(HW_GPU, "Unimplemented component type={}", static_cast<u32>(type));
+            UNREACHABLE();
+        }
+    }
+
+    static ComponentType ComponentTypeFromRenderTarget(Tegra::RenderTargetFormat format) {
+        // TODO(Subv): Implement more render targets
+        switch (format) {
+        case Tegra::RenderTargetFormat::RGBA8_UNORM:
+        case Tegra::RenderTargetFormat::RGBA8_SRGB:
+        case Tegra::RenderTargetFormat::BGRA8_UNORM:
+        case Tegra::RenderTargetFormat::BGRA8_SRGB:
+        case Tegra::RenderTargetFormat::RGB10_A2_UNORM:
+        case Tegra::RenderTargetFormat::R8_UNORM:
+        case Tegra::RenderTargetFormat::RG16_UNORM:
+        case Tegra::RenderTargetFormat::R16_UNORM:
+        case Tegra::RenderTargetFormat::B5G6R5_UNORM:
+        case Tegra::RenderTargetFormat::BGR5A1_UNORM:
+        case Tegra::RenderTargetFormat::RG8_UNORM:
+        case Tegra::RenderTargetFormat::RGBA16_UNORM:
+            return ComponentType::UNorm;
+        case Tegra::RenderTargetFormat::RGBA8_SNORM:
+        case Tegra::RenderTargetFormat::RG16_SNORM:
+        case Tegra::RenderTargetFormat::R16_SNORM:
+        case Tegra::RenderTargetFormat::RG8_SNORM:
+            return ComponentType::SNorm;
+        case Tegra::RenderTargetFormat::RGBA16_FLOAT:
+        case Tegra::RenderTargetFormat::R11G11B10_FLOAT:
+        case Tegra::RenderTargetFormat::RGBA32_FLOAT:
+        case Tegra::RenderTargetFormat::RG32_FLOAT:
+        case Tegra::RenderTargetFormat::RG16_FLOAT:
+        case Tegra::RenderTargetFormat::R16_FLOAT:
+        case Tegra::RenderTargetFormat::R32_FLOAT:
+            return ComponentType::Float;
+        case Tegra::RenderTargetFormat::RGBA32_UINT:
+        case Tegra::RenderTargetFormat::RGBA16_UINT:
+        case Tegra::RenderTargetFormat::RG16_UINT:
+        case Tegra::RenderTargetFormat::R8_UINT:
+        case Tegra::RenderTargetFormat::R16_UINT:
+        case Tegra::RenderTargetFormat::RG32_UINT:
+        case Tegra::RenderTargetFormat::R32_UINT:
+        case Tegra::RenderTargetFormat::RGBA8_UINT:
+            return ComponentType::UInt;
+        case Tegra::RenderTargetFormat::RG16_SINT:
+        case Tegra::RenderTargetFormat::R16_SINT:
+            return ComponentType::SInt;
+        default:
+            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
+            UNREACHABLE();
+        }
+    }
+
+    static PixelFormat PixelFormatFromGPUPixelFormat(Tegra::FramebufferConfig::PixelFormat format) {
+        switch (format) {
+        case Tegra::FramebufferConfig::PixelFormat::ABGR8:
+            return PixelFormat::ABGR8U;
+        default:
+            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
+            UNREACHABLE();
+        }
+    }
+
+    static ComponentType ComponentTypeFromDepthFormat(Tegra::DepthFormat format) {
+        switch (format) {
+        case Tegra::DepthFormat::Z16_UNORM:
+        case Tegra::DepthFormat::S8_Z24_UNORM:
+        case Tegra::DepthFormat::Z24_S8_UNORM:
+            return ComponentType::UNorm;
+        case Tegra::DepthFormat::Z32_FLOAT:
+        case Tegra::DepthFormat::Z32_S8_X24_FLOAT:
+            return ComponentType::Float;
+        default:
+            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
+            UNREACHABLE();
+        }
+    }
+
+    static SurfaceType GetFormatType(PixelFormat pixel_format) {
+        if (static_cast<std::size_t>(pixel_format) <
+            static_cast<std::size_t>(PixelFormat::MaxColorFormat)) {
+            return SurfaceType::ColorTexture;
+        }
+
+        if (static_cast<std::size_t>(pixel_format) <
+            static_cast<std::size_t>(PixelFormat::MaxDepthFormat)) {
+            return SurfaceType::Depth;
+        }
+
+        if (static_cast<std::size_t>(pixel_format) <
+            static_cast<std::size_t>(PixelFormat::MaxDepthStencilFormat)) {
+            return SurfaceType::DepthStencil;
+        }
+
+        // TODO(Subv): Implement the other formats
+        ASSERT(false);
+
+        return SurfaceType::Invalid;
+    }
+
+    /// Returns the sizer in bytes of the specified pixel format
+    static constexpr u32 GetBytesPerPixel(PixelFormat pixel_format) {
+        if (pixel_format == SurfaceParams::PixelFormat::Invalid) {
+            return 0;
+        }
+        return GetFormatBpp(pixel_format) / CHAR_BIT;
     }
 
     /// Returns the rectangle corresponding to this surface
-    MathUtil::Rectangle<u32> GetRect(u32 mip_level = 0) const;
+    MathUtil::Rectangle<u32> GetRect() const;
 
     /// Returns the total size of this surface in bytes, adjusted for compression
     std::size_t SizeInBytesRaw(bool ignore_tiled = false) const {
@@ -94,7 +865,7 @@ struct SurfaceParams {
 
     /// Returns the exact size of memory occupied by the texture in VRAM, including mipmaps.
     std::size_t MemorySize() const {
-        std::size_t size = InnerMemorySize(false, is_layered);
+        std::size_t size = InnerMemorySize(is_layered);
         if (is_layered)
             return size * depth;
         return size;
@@ -103,78 +874,12 @@ struct SurfaceParams {
     /// Returns the exact size of the memory occupied by a layer in a texture in VRAM, including
     /// mipmaps.
     std::size_t LayerMemorySize() const {
-        return InnerMemorySize(false, true);
+        return InnerMemorySize(true);
     }
 
     /// Returns the size of a layer of this surface in OpenGL.
-    std::size_t LayerSizeGL(u32 mip_level) const {
-        return InnerMipmapMemorySize(mip_level, true, is_layered, false);
-    }
-
-    std::size_t GetMipmapSizeGL(u32 mip_level, bool ignore_compressed = true) const {
-        std::size_t size = InnerMipmapMemorySize(mip_level, true, is_layered, ignore_compressed);
-        if (is_layered)
-            return size * depth;
-        return size;
-    }
-
-    std::size_t GetMipmapLevelOffset(u32 mip_level) const {
-        std::size_t offset = 0;
-        for (u32 i = 0; i < mip_level; i++)
-            offset += InnerMipmapMemorySize(i, false, is_layered);
-        return offset;
-    }
-
-    std::size_t GetMipmapLevelOffsetGL(u32 mip_level) const {
-        std::size_t offset = 0;
-        for (u32 i = 0; i < mip_level; i++)
-            offset += InnerMipmapMemorySize(i, true, is_layered);
-        return offset;
-    }
-
-    u32 MipWidth(u32 mip_level) const {
-        return std::max(1U, width >> mip_level);
-    }
-
-    u32 MipHeight(u32 mip_level) const {
-        return std::max(1U, height >> mip_level);
-    }
-
-    u32 MipDepth(u32 mip_level) const {
-        return is_layered ? depth : std::max(1U, depth >> mip_level);
-    }
-
-    // Auto block resizing algorithm from:
-    // https://cgit.freedesktop.org/mesa/mesa/tree/src/gallium/drivers/nouveau/nv50/nv50_miptree.c
-    u32 MipBlockHeight(u32 mip_level) const {
-        if (mip_level == 0)
-            return block_height;
-        u32 alt_height = MipHeight(mip_level);
-        u32 h = GetDefaultBlockHeight(pixel_format);
-        u32 blocks_in_y = (alt_height + h - 1) / h;
-        u32 bh = 16;
-        while (bh > 1 && blocks_in_y <= bh * 4) {
-            bh >>= 1;
-        }
-        return bh;
-    }
-
-    u32 MipBlockDepth(u32 mip_level) const {
-        if (mip_level == 0)
-            return block_depth;
-        if (is_layered)
-            return 1;
-        u32 depth = MipDepth(mip_level);
-        u32 bd = 32;
-        while (bd > 1 && depth * 2 <= bd) {
-            bd >>= 1;
-        }
-        if (bd == 32) {
-            u32 bh = MipBlockHeight(mip_level);
-            if (bh >= 4)
-                return 16;
-        }
-        return bd;
+    std::size_t LayerSizeGL() const {
+        return SizeInBytesRaw(true) / depth;
     }
 
     /// Creates SurfaceParams from a texture configuration
@@ -235,10 +940,7 @@ struct SurfaceParams {
     } rt;
 
 private:
-    std::size_t InnerMipmapMemorySize(u32 mip_level, bool force_gl = false, bool layer_only = false,
-                                      bool uncompressed = false) const;
-    std::size_t InnerMemorySize(bool force_gl = false, bool layer_only = false,
-                                bool uncompressed = false) const;
+    std::size_t InnerMemorySize(bool layer_only = false) const;
 };
 
 }; // namespace OpenGL
@@ -300,10 +1002,8 @@ public:
     void UploadGLTexture(GLuint read_fb_handle, GLuint draw_fb_handle);
 
 private:
-    void UploadGLMipmapTexture(u32 mip_map, GLuint read_fb_handle, GLuint draw_fb_handle);
-
     OGLTexture texture;
-    std::vector<std::vector<u8>> gl_buffer;
+    std::vector<u8> gl_buffer;
     SurfaceParams params;
     GLenum gl_target;
     std::size_t cached_size_in_bytes;

src/video_core/renderer_opengl/gl_resource_manager.cpp

@@ -1,188 +0,0 @@
-// Copyright 2015 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <utility>
-#include <glad/glad.h>
-#include "common/common_types.h"
-#include "common/microprofile.h"
-#include "video_core/renderer_opengl/gl_resource_manager.h"
-#include "video_core/renderer_opengl/gl_shader_util.h"
-#include "video_core/renderer_opengl/gl_state.h"
-
-MICROPROFILE_DEFINE(OpenGL_ResourceCreation, "OpenGL", "Resource Creation",
-                    MP_RGB(128, 128, 192));
-MICROPROFILE_DEFINE(OpenGL_ResourceDeletion, "OpenGL", "Resource Deletion",
-                    MP_RGB(128, 128, 192));
-
-namespace OpenGL {
-
-void OGLTexture::Create() {
-    if (handle != 0)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
-    glGenTextures(1, &handle);
-}
-
-void OGLTexture::Release() {
-    if (handle == 0)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
-    glDeleteTextures(1, &handle);
-    OpenGLState::GetCurState().UnbindTexture(handle).Apply();
-    handle = 0;
-}
-
-void OGLSampler::Create() {
-    if (handle != 0)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
-    glGenSamplers(1, &handle);
-}
-
-void OGLSampler::Release() {
-    if (handle == 0)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
-    glDeleteSamplers(1, &handle);
-    OpenGLState::GetCurState().ResetSampler(handle).Apply();
-    handle = 0;
-}
-
-void OGLShader::Create(const char* source, GLenum type) {
-    if (handle != 0)
-        return;
-    if (source == nullptr)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
-    handle = GLShader::LoadShader(source, type);
-}
-
-void OGLShader::Release() {
-    if (handle == 0)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
-    glDeleteShader(handle);
-    handle = 0;
-}
-
-void OGLProgram::CreateFromSource(const char* vert_shader, const char* geo_shader,
-                                  const char* frag_shader, bool separable_program) {
-    OGLShader vert, geo, frag;
-    if (vert_shader)
-        vert.Create(vert_shader, GL_VERTEX_SHADER);
-    if (geo_shader)
-        geo.Create(geo_shader, GL_GEOMETRY_SHADER);
-    if (frag_shader)
-        frag.Create(frag_shader, GL_FRAGMENT_SHADER);
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
-    Create(separable_program, vert.handle, geo.handle, frag.handle);
-}
-
-void OGLProgram::Release() {
-    if (handle == 0)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
-    glDeleteProgram(handle);
-    OpenGLState::GetCurState().ResetProgram(handle).Apply();
-    handle = 0;
-}
-
-void OGLPipeline::Create() {
-    if (handle != 0)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
-    glGenProgramPipelines(1, &handle);
-}
-
-void OGLPipeline::Release() {
-    if (handle == 0)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
-    glDeleteProgramPipelines(1, &handle);
-    OpenGLState::GetCurState().ResetPipeline(handle).Apply();
-    handle = 0;
-}
-
-void OGLBuffer::Create() {
-    if (handle != 0)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
-    glGenBuffers(1, &handle);
-}
-
-void OGLBuffer::Release() {
-    if (handle == 0)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
-    glDeleteBuffers(1, &handle);
-    OpenGLState::GetCurState().ResetBuffer(handle).Apply();
-    handle = 0;
-}
-
-void OGLSync::Create() {
-    if (handle != 0)
-        return;
-
-    // Don't profile here, this one is expected to happen ingame.
-    handle = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
-}
-
-void OGLSync::Release() {
-    if (handle == 0)
-        return;
-
-    // Don't profile here, this one is expected to happen ingame.
-    glDeleteSync(handle);
-    handle = 0;
-}
-
-void OGLVertexArray::Create() {
-    if (handle != 0)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
-    glGenVertexArrays(1, &handle);
-}
-
-void OGLVertexArray::Release() {
-    if (handle == 0)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
-    glDeleteVertexArrays(1, &handle);
-    OpenGLState::GetCurState().ResetVertexArray(handle).Apply();
-    handle = 0;
-}
-
-void OGLFramebuffer::Create() {
-    if (handle != 0)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
-    glGenFramebuffers(1, &handle);
-}
-
-void OGLFramebuffer::Release() {
-    if (handle == 0)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
-    glDeleteFramebuffers(1, &handle);
-    OpenGLState::GetCurState().ResetFramebuffer(handle).Apply();
-    handle = 0;
-}
-
-} // namespace OpenGL

src/video_core/renderer_opengl/gl_resource_manager.h

@@ -8,6 +8,7 @@
 #include <glad/glad.h>
 #include "common/common_types.h"
 #include "video_core/renderer_opengl/gl_shader_util.h"
+#include "video_core/renderer_opengl/gl_state.h"
 
 namespace OpenGL {
 
@@ -28,10 +29,20 @@ public:
     }
 
     /// Creates a new internal OpenGL resource and stores the handle
-    void Create();
+    void Create() {
+        if (handle != 0)
+            return;
+        glGenTextures(1, &handle);
+    }
 
     /// Deletes the internal OpenGL resource
-    void Release();
+    void Release() {
+        if (handle == 0)
+            return;
+        glDeleteTextures(1, &handle);
+        OpenGLState::GetCurState().UnbindTexture(handle).Apply();
+        handle = 0;
+    }
 
     GLuint handle = 0;
 };
@@ -53,10 +64,20 @@ public:
     }
 
     /// Creates a new internal OpenGL resource and stores the handle
-    void Create();
+    void Create() {
+        if (handle != 0)
+            return;
+        glGenSamplers(1, &handle);
+    }
 
     /// Deletes the internal OpenGL resource
-    void Release();
+    void Release() {
+        if (handle == 0)
+            return;
+        glDeleteSamplers(1, &handle);
+        OpenGLState::GetCurState().ResetSampler(handle).Apply();
+        handle = 0;
+    }
 
     GLuint handle = 0;
 };
@@ -77,9 +98,20 @@ public:
         return *this;
     }
 
-    void Create(const char* source, GLenum type);
+    void Create(const char* source, GLenum type) {
+        if (handle != 0)
+            return;
+        if (source == nullptr)
+            return;
+        handle = GLShader::LoadShader(source, type);
+    }
 
-    void Release();
+    void Release() {
+        if (handle == 0)
+            return;
+        glDeleteShader(handle);
+        handle = 0;
+    }
 
     GLuint handle = 0;
 };
@@ -109,10 +141,25 @@ public:
 
     /// Creates a new internal OpenGL resource and stores the handle
     void CreateFromSource(const char* vert_shader, const char* geo_shader, const char* frag_shader,
-                          bool separable_program = false);
+                          bool separable_program = false) {
+        OGLShader vert, geo, frag;
+        if (vert_shader)
+            vert.Create(vert_shader, GL_VERTEX_SHADER);
+        if (geo_shader)
+            geo.Create(geo_shader, GL_GEOMETRY_SHADER);
+        if (frag_shader)
+            frag.Create(frag_shader, GL_FRAGMENT_SHADER);
+        Create(separable_program, vert.handle, geo.handle, frag.handle);
+    }
 
     /// Deletes the internal OpenGL resource
-    void Release();
+    void Release() {
+        if (handle == 0)
+            return;
+        glDeleteProgram(handle);
+        OpenGLState::GetCurState().ResetProgram(handle).Apply();
+        handle = 0;
+    }
 
     GLuint handle = 0;
 };
@@ -131,10 +178,20 @@ public:
     }
 
     /// Creates a new internal OpenGL resource and stores the handle
-    void Create();
+    void Create() {
+        if (handle != 0)
+            return;
+        glGenProgramPipelines(1, &handle);
+    }
 
     /// Deletes the internal OpenGL resource
-    void Release();
+    void Release() {
+        if (handle == 0)
+            return;
+        glDeleteProgramPipelines(1, &handle);
+        OpenGLState::GetCurState().ResetPipeline(handle).Apply();
+        handle = 0;
+    }
 
     GLuint handle = 0;
 };
@@ -156,10 +213,20 @@ public:
     }
 
     /// Creates a new internal OpenGL resource and stores the handle
-    void Create();
+    void Create() {
+        if (handle != 0)
+            return;
+        glGenBuffers(1, &handle);
+    }
 
     /// Deletes the internal OpenGL resource
-    void Release();
+    void Release() {
+        if (handle == 0)
+            return;
+        glDeleteBuffers(1, &handle);
+        OpenGLState::GetCurState().ResetBuffer(handle).Apply();
+        handle = 0;
+    }
 
     GLuint handle = 0;
 };
@@ -180,10 +247,19 @@ public:
     }
 
     /// Creates a new internal OpenGL resource and stores the handle
-    void Create();
+    void Create() {
+        if (handle != 0)
+            return;
+        handle = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+    }
 
     /// Deletes the internal OpenGL resource
-    void Release();
+    void Release() {
+        if (handle == 0)
+            return;
+        glDeleteSync(handle);
+        handle = 0;
+    }
 
     GLsync handle = 0;
 };
@@ -205,10 +281,20 @@ public:
     }
 
     /// Creates a new internal OpenGL resource and stores the handle
-    void Create();
+    void Create() {
+        if (handle != 0)
+            return;
+        glGenVertexArrays(1, &handle);
+    }
 
     /// Deletes the internal OpenGL resource
-    void Release();
+    void Release() {
+        if (handle == 0)
+            return;
+        glDeleteVertexArrays(1, &handle);
+        OpenGLState::GetCurState().ResetVertexArray(handle).Apply();
+        handle = 0;
+    }
 
     GLuint handle = 0;
 };
@@ -230,10 +316,20 @@ public:
     }
 
     /// Creates a new internal OpenGL resource and stores the handle
-    void Create();
+    void Create() {
+        if (handle != 0)
+            return;
+        glGenFramebuffers(1, &handle);
+    }
 
     /// Deletes the internal OpenGL resource
-    void Release();
+    void Release() {
+        if (handle == 0)
+            return;
+        glDeleteFramebuffers(1, &handle);
+        OpenGLState::GetCurState().ResetFramebuffer(handle).Apply();
+        handle = 0;
+    }
 
     GLuint handle = 0;
 };

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -8,7 +8,6 @@
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_opengl/gl_shader_cache.h"
 #include "video_core/renderer_opengl/gl_shader_manager.h"
-#include "video_core/renderer_opengl/utils.h"
 #include "video_core/utils.h"
 
 namespace OpenGL {
@@ -90,7 +89,7 @@ CachedShader::CachedShader(VAddr addr, Maxwell::ShaderProgram program_type)
         shader.Create(program_result.first.c_str(), gl_type);
         program.Create(true, shader.handle);
         SetShaderUniformBlockBindings(program.handle);
-        LabelGLObject(GL_PROGRAM, program.handle, addr);
+        VideoCore::LabelGLObject(GL_PROGRAM, program.handle, addr);
     } else {
         // Store shader's code to lazily build it on draw
         geometry_programs.code = program_result.first;
@@ -131,7 +130,7 @@ GLuint CachedShader::LazyGeometryProgram(OGLProgram& target_program,
     shader.Create(source.c_str(), GL_GEOMETRY_SHADER);
     target_program.Create(true, shader.handle);
     SetShaderUniformBlockBindings(target_program.handle);
-    LabelGLObject(GL_PROGRAM, target_program.handle, addr, debug_name);
+    VideoCore::LabelGLObject(GL_PROGRAM, target_program.handle, addr, debug_name);
     return target_program.handle;
 };
 

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -373,7 +373,6 @@ public:
         if (sets_cc) {
             const std::string zero_condition = "( " + ConvertIntegerSize(value, size) + " == 0 )";
             SetInternalFlag(InternalFlag::ZeroFlag, zero_condition);
-            LOG_WARNING(HW_GPU, "Control Codes Imcomplete.");
         }
     }
 
@@ -1526,10 +1525,6 @@ private:
 
                 regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " * " + op_b, 1, 1,
                                         instr.alu.saturate_d, 0, true);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "FMUL Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             case OpCode::Id::FADD_C:
@@ -1540,10 +1535,6 @@ private:
 
                 regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " + " + op_b, 1, 1,
                                         instr.alu.saturate_d, 0, true);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "FADD Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             case OpCode::Id::MUFU: {
@@ -1597,10 +1588,6 @@ private:
                                         '(' + condition + ") ? min(" + parameters + ") : max(" +
                                             parameters + ')',
                                         1, 1, false, 0, true);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "FMNMX Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             case OpCode::Id::RRO_C:
@@ -1631,10 +1618,6 @@ private:
                                         regs.GetRegisterAsFloat(instr.gpr8) + " * " +
                                             GetImmediate32(instr),
                                         1, 1, instr.fmul32.saturate, 0, true);
-                if (instr.op_32.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "FMUL32 Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             case OpCode::Id::FADD32I: {
@@ -1658,10 +1641,6 @@ private:
                 }
 
                 regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " + " + op_b, 1, 1, false, 0, true);
-                if (instr.op_32.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "FADD32 Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             }
@@ -1682,10 +1661,6 @@ private:
                     std::to_string(instr.bfe.GetLeftShiftValue() + instr.bfe.shift_position) + ')';
 
                 regs.SetRegisterToInteger(instr.gpr0, true, 0, outer_shift, 1, 1);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "BFE Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             default: {
@@ -1723,20 +1698,12 @@ private:
                 // Cast to int is superfluous for arithmetic shift, it's only for a logical shift
                 regs.SetRegisterToInteger(instr.gpr0, true, 0, "int(" + op_a + " >> " + op_b + ')',
                                           1, 1);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "SHR Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             case OpCode::Id::SHL_C:
             case OpCode::Id::SHL_R:
             case OpCode::Id::SHL_IMM:
                 regs.SetRegisterToInteger(instr.gpr0, true, 0, op_a + " << " + op_b, 1, 1);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "SHL Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             default: {
                 LOG_CRITICAL(HW_GPU, "Unhandled shift instruction: {}", opcode->get().GetName());
@@ -1756,10 +1723,6 @@ private:
 
                 regs.SetRegisterToInteger(instr.gpr0, true, 0, op_a + " + " + op_b, 1, 1,
                                           instr.iadd32i.saturate != 0);
-                if (instr.op_32.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "IADD32 Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             case OpCode::Id::LOP32I: {
                 if (instr.alu.lop32i.invert_a)
@@ -1771,10 +1734,6 @@ private:
                 WriteLogicOperation(instr.gpr0, instr.alu.lop32i.operation, op_a, op_b,
                                     Tegra::Shader::PredicateResultMode::None,
                                     Tegra::Shader::Pred::UnusedIndex);
-                if (instr.op_32.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "LOP32I Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             default: {
@@ -1811,10 +1770,6 @@ private:
 
                 regs.SetRegisterToInteger(instr.gpr0, true, 0, op_a + " + " + op_b, 1, 1,
                                           instr.alu.saturate_d);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "IADD Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             case OpCode::Id::IADD3_C:
@@ -1876,11 +1831,6 @@ private:
                 }
 
                 regs.SetRegisterToInteger(instr.gpr0, true, 0, result, 1, 1);
-
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "IADD3 Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             case OpCode::Id::ISCADD_C:
@@ -1896,10 +1846,6 @@ private:
 
                 regs.SetRegisterToInteger(instr.gpr0, true, 0,
                                           "((" + op_a + " << " + shift + ") + " + op_b + ')', 1, 1);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "ISCADD Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             case OpCode::Id::POPC_C:
@@ -1931,10 +1877,6 @@ private:
 
                 WriteLogicOperation(instr.gpr0, instr.alu.lop.operation, op_a, op_b,
                                     instr.alu.lop.pred_result_mode, instr.alu.lop.pred48);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "LOP Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             case OpCode::Id::LOP3_C:
@@ -1950,10 +1892,6 @@ private:
                 }
 
                 WriteLop3Instruction(instr.gpr0, op_a, op_b, op_c, lut);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "LOP3 Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             case OpCode::Id::IMNMX_C:
@@ -1968,10 +1906,6 @@ private:
                                           '(' + condition + ") ? min(" + parameters + ") : max(" +
                                               parameters + ')',
                                           1, 1);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "IMNMX Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             case OpCode::Id::LEA_R2:
@@ -2173,10 +2107,6 @@ private:
 
             regs.SetRegisterToFloat(instr.gpr0, 0, "fma(" + op_a + ", " + op_b + ", " + op_c + ')',
                                     1, 1, instr.alu.saturate_d, 0, true);
-            if (instr.generates_cc) {
-                LOG_CRITICAL(HW_GPU, "FFMA Generates an unhandled Control Code");
-                UNREACHABLE();
-            }
 
             break;
         }
@@ -2282,11 +2212,6 @@ private:
                 }
 
                 regs.SetRegisterToFloat(instr.gpr0, 0, op_a, 1, 1);
-
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "I2F Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             case OpCode::Id::F2F_R: {
@@ -2325,11 +2250,6 @@ private:
                 }
 
                 regs.SetRegisterToFloat(instr.gpr0, 0, op_a, 1, 1, instr.alu.saturate_d);
-
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "F2F Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             case OpCode::Id::F2I_R:
@@ -2379,10 +2299,6 @@ private:
 
                 regs.SetRegisterToInteger(instr.gpr0, instr.conversion.is_output_signed, 0, op_a, 1,
                                           1, false, 0, instr.conversion.dest_size);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "F2I Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
                 break;
             }
             default: {
@@ -3191,11 +3107,6 @@ private:
                 regs.SetRegisterToFloat(instr.gpr0, 0, value, 1, 1);
             }
 
-            if (instr.generates_cc) {
-                LOG_CRITICAL(HW_GPU, "PSET Generates an unhandled Control Code");
-                UNREACHABLE();
-            }
-
             break;
         }
         case OpCode::Type::PredicateSetPredicate: {
@@ -3461,10 +3372,6 @@ private:
             }
 
             regs.SetRegisterToInteger(instr.gpr0, is_signed, 0, sum, 1, 1);
-            if (instr.generates_cc) {
-                LOG_CRITICAL(HW_GPU, "XMAD Generates an unhandled Control Code");
-                UNREACHABLE();
-            }
             break;
         }
         default: {
@@ -3474,12 +3381,6 @@ private:
                     EmitFragmentOutputsWrite();
                 }
 
-                const Tegra::Shader::ControlCode cc = instr.flow_control_code;
-                if (cc != Tegra::Shader::ControlCode::T) {
-                    LOG_CRITICAL(HW_GPU, "EXIT Control Code used: {}", static_cast<u32>(cc));
-                    UNREACHABLE();
-                }
-
                 switch (instr.flow.cond) {
                 case Tegra::Shader::FlowCondition::Always:
                     shader.AddLine("return true;");
@@ -3509,11 +3410,6 @@ private:
 
                 // Enclose "discard" in a conditional, so that GLSL compilation does not complain
                 // about unexecuted instructions that may follow this.
-                const Tegra::Shader::ControlCode cc = instr.flow_control_code;
-                if (cc != Tegra::Shader::ControlCode::T) {
-                    LOG_CRITICAL(HW_GPU, "KIL Control Code used: {}", static_cast<u32>(cc));
-                    UNREACHABLE();
-                }
                 shader.AddLine("if (true) {");
                 ++shader.scope;
                 shader.AddLine("discard;");
@@ -3571,11 +3467,6 @@ private:
             case OpCode::Id::BRA: {
                 ASSERT_MSG(instr.bra.constant_buffer == 0,
                            "BRA with constant buffers are not implemented");
-                const Tegra::Shader::ControlCode cc = instr.flow_control_code;
-                if (cc != Tegra::Shader::ControlCode::T) {
-                    LOG_CRITICAL(HW_GPU, "BRA Control Code used: {}", static_cast<u32>(cc));
-                    UNREACHABLE();
-                }
                 const u32 target = offset + instr.bra.GetBranchTarget();
                 shader.AddLine("{ jmp_to = " + std::to_string(target) + "u; break; }");
                 break;
@@ -3616,21 +3507,13 @@ private:
             }
             case OpCode::Id::SYNC: {
                 // The SYNC opcode jumps to the address previously set by the SSY opcode
-                const Tegra::Shader::ControlCode cc = instr.flow_control_code;
-                if (cc != Tegra::Shader::ControlCode::T) {
-                    LOG_CRITICAL(HW_GPU, "SYNC Control Code used: {}", static_cast<u32>(cc));
-                    UNREACHABLE();
-                }
+                ASSERT(instr.flow.cond == Tegra::Shader::FlowCondition::Always);
                 EmitPopFromFlowStack();
                 break;
             }
             case OpCode::Id::BRK: {
                 // The BRK opcode jumps to the address previously set by the PBK opcode
-                const Tegra::Shader::ControlCode cc = instr.flow_control_code;
-                if (cc != Tegra::Shader::ControlCode::T) {
-                    LOG_CRITICAL(HW_GPU, "BRK Control Code used: {}", static_cast<u32>(cc));
-                    UNREACHABLE();
-                }
+                ASSERT(instr.flow.cond == Tegra::Shader::FlowCondition::Always);
                 EmitPopFromFlowStack();
                 break;
             }
@@ -3660,11 +3543,6 @@ private:
                 regs.SetRegisterToInteger(instr.gpr0, result_signed, 1, result, 1, 1,
                                           instr.vmad.saturate == 1, 0, Register::Size::Word,
                                           instr.vmad.cc);
-                if (instr.generates_cc) {
-                    LOG_CRITICAL(HW_GPU, "VMAD Generates an unhandled Control Code");
-                    UNREACHABLE();
-                }
-
                 break;
             }
             case OpCode::Id::VSETP: {

src/video_core/renderer_opengl/gl_shader_manager.h

@@ -7,7 +7,6 @@
 #include <glad/glad.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 OpenGL::GLShader {

src/video_core/renderer_opengl/gl_state.cpp

@@ -89,18 +89,7 @@ OpenGLState::OpenGLState() {
     point.size = 1;
 }
 
-void OpenGLState::ApplyDefaultState() {
-    glDisable(GL_FRAMEBUFFER_SRGB);
-    glDisable(GL_CULL_FACE);
-    glDisable(GL_DEPTH_TEST);
-    glDisable(GL_PRIMITIVE_RESTART);
-    glDisable(GL_STENCIL_TEST);
-    glEnable(GL_BLEND);
-    glDisable(GL_COLOR_LOGIC_OP);
-    glDisable(GL_SCISSOR_TEST);
-}
-
-void OpenGLState::ApplySRgb() const {
+void OpenGLState::Apply() const {
     // sRGB
     if (framebuffer_srgb.enabled != cur_state.framebuffer_srgb.enabled) {
         if (framebuffer_srgb.enabled) {
@@ -111,122 +100,96 @@ void OpenGLState::ApplySRgb() const {
             glDisable(GL_FRAMEBUFFER_SRGB);
         }
     }
-}
-
-void OpenGLState::ApplyCulling() const {
     // Culling
-    const bool cull_changed = cull.enabled != cur_state.cull.enabled;
-    if (cull_changed) {
+    if (cull.enabled != cur_state.cull.enabled) {
         if (cull.enabled) {
             glEnable(GL_CULL_FACE);
         } else {
             glDisable(GL_CULL_FACE);
         }
     }
-    if (cull.enabled) {
-        if (cull_changed || cull.mode != cur_state.cull.mode) {
-            glCullFace(cull.mode);
-        }
 
-        if (cull_changed || cull.front_face != cur_state.cull.front_face) {
-            glFrontFace(cull.front_face);
-        }
+    if (cull.mode != cur_state.cull.mode) {
+        glCullFace(cull.mode);
+    }
+
+    if (cull.front_face != cur_state.cull.front_face) {
+        glFrontFace(cull.front_face);
     }
-}
 
-void OpenGLState::ApplyDepth() const {
     // Depth test
-    const bool depth_test_changed = depth.test_enabled != cur_state.depth.test_enabled;
-    if (depth_test_changed) {
+    if (depth.test_enabled != cur_state.depth.test_enabled) {
         if (depth.test_enabled) {
             glEnable(GL_DEPTH_TEST);
         } else {
             glDisable(GL_DEPTH_TEST);
         }
     }
-    if (depth.test_enabled &&
-        (depth_test_changed || depth.test_func != cur_state.depth.test_func)) {
+
+    if (depth.test_func != cur_state.depth.test_func) {
         glDepthFunc(depth.test_func);
     }
+
     // Depth mask
     if (depth.write_mask != cur_state.depth.write_mask) {
         glDepthMask(depth.write_mask);
     }
+
     // Depth range
     if (depth.depth_range_near != cur_state.depth.depth_range_near ||
         depth.depth_range_far != cur_state.depth.depth_range_far) {
         glDepthRange(depth.depth_range_near, depth.depth_range_far);
     }
-}
 
-void OpenGLState::ApplyPrimitiveRestart() const {
-    const bool primitive_restart_changed =
-        primitive_restart.enabled != cur_state.primitive_restart.enabled;
-    if (primitive_restart_changed) {
+    // Primitive restart
+    if (primitive_restart.enabled != cur_state.primitive_restart.enabled) {
         if (primitive_restart.enabled) {
             glEnable(GL_PRIMITIVE_RESTART);
         } else {
             glDisable(GL_PRIMITIVE_RESTART);
         }
     }
-    if (primitive_restart_changed ||
-        (primitive_restart.enabled &&
-         primitive_restart.index != cur_state.primitive_restart.index)) {
+    if (primitive_restart.index != cur_state.primitive_restart.index) {
         glPrimitiveRestartIndex(primitive_restart.index);
     }
-}
 
-void OpenGLState::ApplyStencilTest() const {
-    const bool stencil_test_changed = stencil.test_enabled != cur_state.stencil.test_enabled;
-    if (stencil_test_changed) {
+    // Color mask
+    if (color_mask.red_enabled != cur_state.color_mask.red_enabled ||
+        color_mask.green_enabled != cur_state.color_mask.green_enabled ||
+        color_mask.blue_enabled != cur_state.color_mask.blue_enabled ||
+        color_mask.alpha_enabled != cur_state.color_mask.alpha_enabled) {
+        glColorMask(color_mask.red_enabled, color_mask.green_enabled, color_mask.blue_enabled,
+                    color_mask.alpha_enabled);
+    }
+
+    // Stencil test
+    if (stencil.test_enabled != cur_state.stencil.test_enabled) {
         if (stencil.test_enabled) {
             glEnable(GL_STENCIL_TEST);
         } else {
             glDisable(GL_STENCIL_TEST);
         }
     }
-    if (stencil.test_enabled) {
-        auto config_stencil = [stencil_test_changed](GLenum face, const auto& config,
-                                                     const auto& prev_config) {
-            if (stencil_test_changed || config.test_func != prev_config.test_func ||
-                config.test_ref != prev_config.test_ref ||
-                config.test_mask != prev_config.test_mask) {
-                glStencilFuncSeparate(face, config.test_func, config.test_ref, config.test_mask);
-            }
-            if (stencil_test_changed || config.action_depth_fail != prev_config.action_depth_fail ||
-                config.action_depth_pass != prev_config.action_depth_pass ||
-                config.action_stencil_fail != prev_config.action_stencil_fail) {
-                glStencilOpSeparate(face, config.action_stencil_fail, config.action_depth_fail,
-                                    config.action_depth_pass);
-            }
-            if (config.write_mask != prev_config.write_mask) {
-                glStencilMaskSeparate(face, config.write_mask);
-            }
-        };
-        config_stencil(GL_FRONT, stencil.front, cur_state.stencil.front);
-        config_stencil(GL_BACK, stencil.back, cur_state.stencil.back);
-    }
-}
-
-void OpenGLState::ApplyScissorTest() const {
-    const bool scissor_changed = scissor.enabled != cur_state.scissor.enabled;
-    if (scissor_changed) {
-        if (scissor.enabled) {
-            glEnable(GL_SCISSOR_TEST);
-        } else {
-            glDisable(GL_SCISSOR_TEST);
+    auto config_stencil = [](GLenum face, const auto& config, const auto& prev_config) {
+        if (config.test_func != prev_config.test_func || config.test_ref != prev_config.test_ref ||
+            config.test_mask != prev_config.test_mask) {
+            glStencilFuncSeparate(face, config.test_func, config.test_ref, config.test_mask);
         }
-    }
-    if (scissor_changed || scissor_changed || scissor.x != cur_state.scissor.x ||
-        scissor.y != cur_state.scissor.y || scissor.width != cur_state.scissor.width ||
-        scissor.height != cur_state.scissor.height) {
-        glScissor(scissor.x, scissor.y, scissor.width, scissor.height);
-    }
-}
+        if (config.action_depth_fail != prev_config.action_depth_fail ||
+            config.action_depth_pass != prev_config.action_depth_pass ||
+            config.action_stencil_fail != prev_config.action_stencil_fail) {
+            glStencilOpSeparate(face, config.action_stencil_fail, config.action_depth_fail,
+                                config.action_depth_pass);
+        }
+        if (config.write_mask != prev_config.write_mask) {
+            glStencilMaskSeparate(face, config.write_mask);
+        }
+    };
+    config_stencil(GL_FRONT, stencil.front, cur_state.stencil.front);
+    config_stencil(GL_BACK, stencil.back, cur_state.stencil.back);
 
-void OpenGLState::ApplyBlending() const {
-    const bool blend_changed = blend.enabled != cur_state.blend.enabled;
-    if (blend_changed) {
+    // Blending
+    if (blend.enabled != cur_state.blend.enabled) {
         if (blend.enabled) {
             ASSERT(!logic_op.enabled);
             glEnable(GL_BLEND);
@@ -234,32 +197,29 @@ void OpenGLState::ApplyBlending() const {
             glDisable(GL_BLEND);
         }
     }
-    if (blend.enabled) {
-        if (blend_changed || blend.color.red != cur_state.blend.color.red ||
-            blend.color.green != cur_state.blend.color.green ||
-            blend.color.blue != cur_state.blend.color.blue ||
-            blend.color.alpha != cur_state.blend.color.alpha) {
-            glBlendColor(blend.color.red, blend.color.green, blend.color.blue, blend.color.alpha);
-        }
 
-        if (blend_changed || blend.src_rgb_func != cur_state.blend.src_rgb_func ||
-            blend.dst_rgb_func != cur_state.blend.dst_rgb_func ||
-            blend.src_a_func != cur_state.blend.src_a_func ||
-            blend.dst_a_func != cur_state.blend.dst_a_func) {
-            glBlendFuncSeparate(blend.src_rgb_func, blend.dst_rgb_func, blend.src_a_func,
-                                blend.dst_a_func);
-        }
-
-        if (blend_changed || blend.rgb_equation != cur_state.blend.rgb_equation ||
-            blend.a_equation != cur_state.blend.a_equation) {
-            glBlendEquationSeparate(blend.rgb_equation, blend.a_equation);
-        }
+    if (blend.color.red != cur_state.blend.color.red ||
+        blend.color.green != cur_state.blend.color.green ||
+        blend.color.blue != cur_state.blend.color.blue ||
+        blend.color.alpha != cur_state.blend.color.alpha) {
+        glBlendColor(blend.color.red, blend.color.green, blend.color.blue, blend.color.alpha);
     }
-}
 
-void OpenGLState::ApplyLogicOp() const {
-    const bool logic_op_changed = logic_op.enabled != cur_state.logic_op.enabled;
-    if (logic_op_changed) {
+    if (blend.src_rgb_func != cur_state.blend.src_rgb_func ||
+        blend.dst_rgb_func != cur_state.blend.dst_rgb_func ||
+        blend.src_a_func != cur_state.blend.src_a_func ||
+        blend.dst_a_func != cur_state.blend.dst_a_func) {
+        glBlendFuncSeparate(blend.src_rgb_func, blend.dst_rgb_func, blend.src_a_func,
+                            blend.dst_a_func);
+    }
+
+    if (blend.rgb_equation != cur_state.blend.rgb_equation ||
+        blend.a_equation != cur_state.blend.a_equation) {
+        glBlendEquationSeparate(blend.rgb_equation, blend.a_equation);
+    }
+
+    // Logic Operation
+    if (logic_op.enabled != cur_state.logic_op.enabled) {
         if (logic_op.enabled) {
             ASSERT(!blend.enabled);
             glEnable(GL_COLOR_LOGIC_OP);
@@ -268,13 +228,11 @@ void OpenGLState::ApplyLogicOp() const {
         }
     }
 
-    if (logic_op.enabled &&
-        (logic_op_changed || logic_op.operation != cur_state.logic_op.operation)) {
+    if (logic_op.operation != cur_state.logic_op.operation) {
         glLogicOp(logic_op.operation);
     }
-}
 
-void OpenGLState::ApplyTextures() const {
+    // Textures
     for (std::size_t i = 0; i < std::size(texture_units); ++i) {
         const auto& texture_unit = texture_units[i];
         const auto& cur_state_texture_unit = cur_state.texture_units[i];
@@ -293,29 +251,28 @@ void OpenGLState::ApplyTextures() const {
             glTexParameteriv(texture_unit.target, GL_TEXTURE_SWIZZLE_RGBA, mask.data());
         }
     }
-}
 
-void OpenGLState::ApplySamplers() const {
-    bool has_delta{};
-    std::size_t first{}, last{};
-    std::array<GLuint, Tegra::Engines::Maxwell3D::Regs::NumTextureSamplers> samplers;
-    for (std::size_t i = 0; i < std::size(samplers); ++i) {
-        samplers[i] = texture_units[i].sampler;
-        if (samplers[i] != cur_state.texture_units[i].sampler) {
-            if (!has_delta) {
-                first = i;
-                has_delta = true;
+    // Samplers
+    {
+        bool has_delta{};
+        std::size_t first{}, last{};
+        std::array<GLuint, Tegra::Engines::Maxwell3D::Regs::NumTextureSamplers> samplers;
+        for (std::size_t i = 0; i < std::size(samplers); ++i) {
+            samplers[i] = texture_units[i].sampler;
+            if (samplers[i] != cur_state.texture_units[i].sampler) {
+                if (!has_delta) {
+                    first = i;
+                    has_delta = true;
+                }
+                last = i;
             }
-            last = i;
+        }
+        if (has_delta) {
+            glBindSamplers(static_cast<GLuint>(first), static_cast<GLsizei>(last - first + 1),
+                           samplers.data());
         }
     }
-    if (has_delta) {
-        glBindSamplers(static_cast<GLuint>(first), static_cast<GLsizei>(last - first + 1),
-                       samplers.data());
-    }
-}
 
-void OpenGLState::Apply() const {
     // Framebuffer
     if (draw.read_framebuffer != cur_state.draw.read_framebuffer) {
         glBindFramebuffer(GL_READ_FRAMEBUFFER, draw.read_framebuffer);
@@ -348,12 +305,27 @@ void OpenGLState::Apply() const {
     if (draw.program_pipeline != cur_state.draw.program_pipeline) {
         glBindProgramPipeline(draw.program_pipeline);
     }
-    // Viewport
+
+    // Scissor test
+    if (scissor.enabled != cur_state.scissor.enabled) {
+        if (scissor.enabled) {
+            glEnable(GL_SCISSOR_TEST);
+        } else {
+            glDisable(GL_SCISSOR_TEST);
+        }
+    }
+
+    if (scissor.x != cur_state.scissor.x || scissor.y != cur_state.scissor.y ||
+        scissor.width != cur_state.scissor.width || scissor.height != cur_state.scissor.height) {
+        glScissor(scissor.x, scissor.y, scissor.width, scissor.height);
+    }
+
     if (viewport.x != cur_state.viewport.x || viewport.y != cur_state.viewport.y ||
         viewport.width != cur_state.viewport.width ||
         viewport.height != cur_state.viewport.height) {
         glViewport(viewport.x, viewport.y, viewport.width, viewport.height);
     }
+
     // Clip distance
     for (std::size_t i = 0; i < clip_distance.size(); ++i) {
         if (clip_distance[i] != cur_state.clip_distance[i]) {
@@ -364,28 +336,12 @@ void OpenGLState::Apply() const {
             }
         }
     }
-    // Color mask
-    if (color_mask.red_enabled != cur_state.color_mask.red_enabled ||
-        color_mask.green_enabled != cur_state.color_mask.green_enabled ||
-        color_mask.blue_enabled != cur_state.color_mask.blue_enabled ||
-        color_mask.alpha_enabled != cur_state.color_mask.alpha_enabled) {
-        glColorMask(color_mask.red_enabled, color_mask.green_enabled, color_mask.blue_enabled,
-                    color_mask.alpha_enabled);
-    }
+
     // Point
     if (point.size != cur_state.point.size) {
         glPointSize(point.size);
     }
-    ApplyScissorTest();
-    ApplyStencilTest();
-    ApplySRgb();
-    ApplyCulling();
-    ApplyDepth();
-    ApplyPrimitiveRestart();
-    ApplyBlending();
-    ApplyLogicOp();
-    ApplyTextures();
-    ApplySamplers();
+
     cur_state = *this;
 }
 

src/video_core/renderer_opengl/gl_state.h

@@ -173,8 +173,7 @@ public:
     }
     /// Apply this state as the current OpenGL state
     void Apply() const;
-    /// Set the initial OpenGL state
-    static void ApplyDefaultState();
+
     /// Resets any references to the given resource
     OpenGLState& UnbindTexture(GLuint handle);
     OpenGLState& ResetSampler(GLuint handle);
@@ -189,16 +188,6 @@ private:
     // Workaround for sRGB problems caused by
     // QT not supporting srgb output
     static bool s_rgb_used;
-    void ApplySRgb() const;
-    void ApplyCulling() const;
-    void ApplyDepth() const;
-    void ApplyPrimitiveRestart() const;
-    void ApplyStencilTest() const;
-    void ApplyScissorTest() const;
-    void ApplyBlending() const;
-    void ApplyLogicOp() const;
-    void ApplyTextures() const;
-    void ApplySamplers() const;
 };
 
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_stream_buffer.cpp

@@ -6,13 +6,9 @@
 #include <vector>
 #include "common/alignment.h"
 #include "common/assert.h"
-#include "common/microprofile.h"
 #include "video_core/renderer_opengl/gl_state.h"
 #include "video_core/renderer_opengl/gl_stream_buffer.h"
 
-MICROPROFILE_DEFINE(OpenGL_StreamBuffer, "OpenGL", "Stream Buffer Orphaning",
-                    MP_RGB(128, 128, 192));
-
 namespace OpenGL {
 
 OGLStreamBuffer::OGLStreamBuffer(GLenum target, GLsizeiptr size, bool prefer_coherent)
@@ -79,7 +75,6 @@ std::tuple<u8*, GLintptr, bool> OGLStreamBuffer::Map(GLsizeiptr size, GLintptr a
     }
 
     if (invalidate || !persistent) {
-        MICROPROFILE_SCOPE(OpenGL_StreamBuffer);
         GLbitfield flags = GL_MAP_WRITE_BIT | (persistent ? GL_MAP_PERSISTENT_BIT : 0) |
                            (coherent ? GL_MAP_COHERENT_BIT : GL_MAP_FLUSH_EXPLICIT_BIT) |
                            (invalidate ? GL_MAP_INVALIDATE_BUFFER_BIT : GL_MAP_UNSYNCHRONIZED_BIT);

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -135,29 +135,12 @@ inline GLenum PrimitiveTopology(Maxwell::PrimitiveTopology topology) {
     return {};
 }
 
-inline GLenum TextureFilterMode(Tegra::Texture::TextureFilter filter_mode,
-                                Tegra::Texture::TextureMipmapFilter mip_filter_mode) {
+inline GLenum TextureFilterMode(Tegra::Texture::TextureFilter filter_mode) {
     switch (filter_mode) {
-    case Tegra::Texture::TextureFilter::Linear: {
-        switch (mip_filter_mode) {
-        case Tegra::Texture::TextureMipmapFilter::None:
-            return GL_LINEAR;
-        case Tegra::Texture::TextureMipmapFilter::Nearest:
-            return GL_NEAREST_MIPMAP_LINEAR;
-        case Tegra::Texture::TextureMipmapFilter::Linear:
-            return GL_LINEAR_MIPMAP_LINEAR;
-        }
-    }
-    case Tegra::Texture::TextureFilter::Nearest: {
-        switch (mip_filter_mode) {
-        case Tegra::Texture::TextureMipmapFilter::None:
-            return GL_NEAREST;
-        case Tegra::Texture::TextureMipmapFilter::Nearest:
-            return GL_NEAREST_MIPMAP_NEAREST;
-        case Tegra::Texture::TextureMipmapFilter::Linear:
-            return GL_LINEAR_MIPMAP_NEAREST;
-        }
-    }
+    case Tegra::Texture::TextureFilter::Linear:
+        return GL_LINEAR;
+    case Tegra::Texture::TextureFilter::Nearest:
+        return GL_NEAREST;
     }
     LOG_CRITICAL(Render_OpenGL, "Unimplemented texture filter mode={}",
                  static_cast<u32>(filter_mode));

src/video_core/renderer_opengl/utils.cpp

@@ -1,38 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <string>
-#include <fmt/format.h>
-#include <glad/glad.h>
-#include "common/common_types.h"
-#include "video_core/renderer_opengl/utils.h"
-
-namespace OpenGL {
-
-void LabelGLObject(GLenum identifier, GLuint handle, VAddr addr, std::string extra_info) {
-    if (!GLAD_GL_KHR_debug) {
-        return; // We don't need to throw an error as this is just for debugging
-    }
-    const std::string nice_addr = fmt::format("0x{:016x}", addr);
-    std::string object_label;
-
-    if (extra_info.empty()) {
-        switch (identifier) {
-        case GL_TEXTURE:
-            object_label = "Texture@" + nice_addr;
-            break;
-        case GL_PROGRAM:
-            object_label = "Shader@" + nice_addr;
-            break;
-        default:
-            object_label = fmt::format("Object(0x{:x})@{}", identifier, nice_addr);
-            break;
-        }
-    } else {
-        object_label = extra_info + '@' + nice_addr;
-    }
-    glObjectLabel(identifier, handle, -1, static_cast<const GLchar*>(object_label.c_str()));
-}
-
-} // namespace OpenGL

src/video_core/renderer_opengl/utils.h

@@ -1,15 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-#include <glad/glad.h>
-#include "common/common_types.h"
-
-namespace OpenGL {
-
-void LabelGLObject(GLenum identifier, GLuint handle, VAddr addr, std::string extra_info = "");
-
-} // namespace OpenGL

src/video_core/surface.cpp

@@ -1,486 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/common_types.h"
-#include "common/math_util.h"
-#include "video_core/surface.h"
-
-namespace VideoCore::Surface {
-
-SurfaceTarget SurfaceTargetFromTextureType(Tegra::Texture::TextureType texture_type) {
-    switch (texture_type) {
-    case Tegra::Texture::TextureType::Texture1D:
-        return SurfaceTarget::Texture1D;
-    case Tegra::Texture::TextureType::Texture2D:
-    case Tegra::Texture::TextureType::Texture2DNoMipmap:
-        return SurfaceTarget::Texture2D;
-    case Tegra::Texture::TextureType::Texture3D:
-        return SurfaceTarget::Texture3D;
-    case Tegra::Texture::TextureType::TextureCubemap:
-        return SurfaceTarget::TextureCubemap;
-    case Tegra::Texture::TextureType::TextureCubeArray:
-        return SurfaceTarget::TextureCubeArray;
-    case Tegra::Texture::TextureType::Texture1DArray:
-        return SurfaceTarget::Texture1DArray;
-    case Tegra::Texture::TextureType::Texture2DArray:
-        return SurfaceTarget::Texture2DArray;
-    default:
-        LOG_CRITICAL(HW_GPU, "Unimplemented texture_type={}", static_cast<u32>(texture_type));
-        UNREACHABLE();
-        return SurfaceTarget::Texture2D;
-    }
-}
-
-bool SurfaceTargetIsLayered(SurfaceTarget target) {
-    switch (target) {
-    case SurfaceTarget::Texture1D:
-    case SurfaceTarget::Texture2D:
-    case SurfaceTarget::Texture3D:
-        return false;
-    case SurfaceTarget::Texture1DArray:
-    case SurfaceTarget::Texture2DArray:
-    case SurfaceTarget::TextureCubemap:
-    case SurfaceTarget::TextureCubeArray:
-        return true;
-    default:
-        LOG_CRITICAL(HW_GPU, "Unimplemented surface_target={}", static_cast<u32>(target));
-        UNREACHABLE();
-        return false;
-    }
-}
-
-PixelFormat PixelFormatFromDepthFormat(Tegra::DepthFormat format) {
-    switch (format) {
-    case Tegra::DepthFormat::S8_Z24_UNORM:
-        return PixelFormat::S8Z24;
-    case Tegra::DepthFormat::Z24_S8_UNORM:
-        return PixelFormat::Z24S8;
-    case Tegra::DepthFormat::Z32_FLOAT:
-        return PixelFormat::Z32F;
-    case Tegra::DepthFormat::Z16_UNORM:
-        return PixelFormat::Z16;
-    case Tegra::DepthFormat::Z32_S8_X24_FLOAT:
-        return PixelFormat::Z32FS8;
-    default:
-        LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
-        UNREACHABLE();
-    }
-}
-
-PixelFormat PixelFormatFromRenderTargetFormat(Tegra::RenderTargetFormat format) {
-    switch (format) {
-        // TODO (Hexagon12): Converting SRGBA to RGBA is a hack and doesn't completely correct the
-        // gamma.
-    case Tegra::RenderTargetFormat::RGBA8_SRGB:
-        return PixelFormat::RGBA8_SRGB;
-    case Tegra::RenderTargetFormat::RGBA8_UNORM:
-        return PixelFormat::ABGR8U;
-    case Tegra::RenderTargetFormat::RGBA8_SNORM:
-        return PixelFormat::ABGR8S;
-    case Tegra::RenderTargetFormat::RGBA8_UINT:
-        return PixelFormat::ABGR8UI;
-    case Tegra::RenderTargetFormat::BGRA8_SRGB:
-        return PixelFormat::BGRA8_SRGB;
-    case Tegra::RenderTargetFormat::BGRA8_UNORM:
-        return PixelFormat::BGRA8;
-    case Tegra::RenderTargetFormat::RGB10_A2_UNORM:
-        return PixelFormat::A2B10G10R10U;
-    case Tegra::RenderTargetFormat::RGBA16_FLOAT:
-        return PixelFormat::RGBA16F;
-    case Tegra::RenderTargetFormat::RGBA16_UNORM:
-        return PixelFormat::RGBA16U;
-    case Tegra::RenderTargetFormat::RGBA16_UINT:
-        return PixelFormat::RGBA16UI;
-    case Tegra::RenderTargetFormat::RGBA32_FLOAT:
-        return PixelFormat::RGBA32F;
-    case Tegra::RenderTargetFormat::RG32_FLOAT:
-        return PixelFormat::RG32F;
-    case Tegra::RenderTargetFormat::R11G11B10_FLOAT:
-        return PixelFormat::R11FG11FB10F;
-    case Tegra::RenderTargetFormat::B5G6R5_UNORM:
-        return PixelFormat::B5G6R5U;
-    case Tegra::RenderTargetFormat::BGR5A1_UNORM:
-        return PixelFormat::A1B5G5R5U;
-    case Tegra::RenderTargetFormat::RGBA32_UINT:
-        return PixelFormat::RGBA32UI;
-    case Tegra::RenderTargetFormat::R8_UNORM:
-        return PixelFormat::R8U;
-    case Tegra::RenderTargetFormat::R8_UINT:
-        return PixelFormat::R8UI;
-    case Tegra::RenderTargetFormat::RG16_FLOAT:
-        return PixelFormat::RG16F;
-    case Tegra::RenderTargetFormat::RG16_UINT:
-        return PixelFormat::RG16UI;
-    case Tegra::RenderTargetFormat::RG16_SINT:
-        return PixelFormat::RG16I;
-    case Tegra::RenderTargetFormat::RG16_UNORM:
-        return PixelFormat::RG16;
-    case Tegra::RenderTargetFormat::RG16_SNORM:
-        return PixelFormat::RG16S;
-    case Tegra::RenderTargetFormat::RG8_UNORM:
-        return PixelFormat::RG8U;
-    case Tegra::RenderTargetFormat::RG8_SNORM:
-        return PixelFormat::RG8S;
-    case Tegra::RenderTargetFormat::R16_FLOAT:
-        return PixelFormat::R16F;
-    case Tegra::RenderTargetFormat::R16_UNORM:
-        return PixelFormat::R16U;
-    case Tegra::RenderTargetFormat::R16_SNORM:
-        return PixelFormat::R16S;
-    case Tegra::RenderTargetFormat::R16_UINT:
-        return PixelFormat::R16UI;
-    case Tegra::RenderTargetFormat::R16_SINT:
-        return PixelFormat::R16I;
-    case Tegra::RenderTargetFormat::R32_FLOAT:
-        return PixelFormat::R32F;
-    case Tegra::RenderTargetFormat::R32_UINT:
-        return PixelFormat::R32UI;
-    case Tegra::RenderTargetFormat::RG32_UINT:
-        return PixelFormat::RG32UI;
-    default:
-        LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
-        UNREACHABLE();
-    }
-}
-
-PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
-                                         Tegra::Texture::ComponentType component_type,
-                                         bool is_srgb) {
-    // TODO(Subv): Properly implement this
-    switch (format) {
-    case Tegra::Texture::TextureFormat::A8R8G8B8:
-        if (is_srgb) {
-            return PixelFormat::RGBA8_SRGB;
-        }
-        switch (component_type) {
-        case Tegra::Texture::ComponentType::UNORM:
-            return PixelFormat::ABGR8U;
-        case Tegra::Texture::ComponentType::SNORM:
-            return PixelFormat::ABGR8S;
-        case Tegra::Texture::ComponentType::UINT:
-            return PixelFormat::ABGR8UI;
-        }
-        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
-        UNREACHABLE();
-    case Tegra::Texture::TextureFormat::B5G6R5:
-        switch (component_type) {
-        case Tegra::Texture::ComponentType::UNORM:
-            return PixelFormat::B5G6R5U;
-        }
-        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
-        UNREACHABLE();
-    case Tegra::Texture::TextureFormat::A2B10G10R10:
-        switch (component_type) {
-        case Tegra::Texture::ComponentType::UNORM:
-            return PixelFormat::A2B10G10R10U;
-        }
-        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
-        UNREACHABLE();
-    case Tegra::Texture::TextureFormat::A1B5G5R5:
-        switch (component_type) {
-        case Tegra::Texture::ComponentType::UNORM:
-            return PixelFormat::A1B5G5R5U;
-        }
-        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
-        UNREACHABLE();
-    case Tegra::Texture::TextureFormat::R8:
-        switch (component_type) {
-        case Tegra::Texture::ComponentType::UNORM:
-            return PixelFormat::R8U;
-        case Tegra::Texture::ComponentType::UINT:
-            return PixelFormat::R8UI;
-        }
-        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
-        UNREACHABLE();
-    case Tegra::Texture::TextureFormat::G8R8:
-        switch (component_type) {
-        case Tegra::Texture::ComponentType::UNORM:
-            return PixelFormat::G8R8U;
-        case Tegra::Texture::ComponentType::SNORM:
-            return PixelFormat::G8R8S;
-        }
-        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
-        UNREACHABLE();
-    case Tegra::Texture::TextureFormat::R16_G16_B16_A16:
-        switch (component_type) {
-        case Tegra::Texture::ComponentType::UNORM:
-            return PixelFormat::RGBA16U;
-        case Tegra::Texture::ComponentType::FLOAT:
-            return PixelFormat::RGBA16F;
-        }
-        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
-        UNREACHABLE();
-    case Tegra::Texture::TextureFormat::BF10GF11RF11:
-        switch (component_type) {
-        case Tegra::Texture::ComponentType::FLOAT:
-            return PixelFormat::R11FG11FB10F;
-        }
-        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
-        UNREACHABLE();
-    case Tegra::Texture::TextureFormat::R32_G32_B32_A32:
-        switch (component_type) {
-        case Tegra::Texture::ComponentType::FLOAT:
-            return PixelFormat::RGBA32F;
-        case Tegra::Texture::ComponentType::UINT:
-            return PixelFormat::RGBA32UI;
-        }
-        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
-        UNREACHABLE();
-    case Tegra::Texture::TextureFormat::R32_G32:
-        switch (component_type) {
-        case Tegra::Texture::ComponentType::FLOAT:
-            return PixelFormat::RG32F;
-        case Tegra::Texture::ComponentType::UINT:
-            return PixelFormat::RG32UI;
-        }
-        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
-        UNREACHABLE();
-    case Tegra::Texture::TextureFormat::R32_G32_B32:
-        switch (component_type) {
-        case Tegra::Texture::ComponentType::FLOAT:
-            return PixelFormat::RGB32F;
-        }
-        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
-        UNREACHABLE();
-    case Tegra::Texture::TextureFormat::R16:
-        switch (component_type) {
-        case Tegra::Texture::ComponentType::FLOAT:
-            return PixelFormat::R16F;
-        case Tegra::Texture::ComponentType::UNORM:
-            return PixelFormat::R16U;
-        case Tegra::Texture::ComponentType::SNORM:
-            return PixelFormat::R16S;
-        case Tegra::Texture::ComponentType::UINT:
-            return PixelFormat::R16UI;
-        case Tegra::Texture::ComponentType::SINT:
-            return PixelFormat::R16I;
-        }
-        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
-        UNREACHABLE();
-    case Tegra::Texture::TextureFormat::R32:
-        switch (component_type) {
-        case Tegra::Texture::ComponentType::FLOAT:
-            return PixelFormat::R32F;
-        case Tegra::Texture::ComponentType::UINT:
-            return PixelFormat::R32UI;
-        }
-        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
-        UNREACHABLE();
-    case Tegra::Texture::TextureFormat::ZF32:
-        return PixelFormat::Z32F;
-    case Tegra::Texture::TextureFormat::Z16:
-        return PixelFormat::Z16;
-    case Tegra::Texture::TextureFormat::Z24S8:
-        return PixelFormat::Z24S8;
-    case Tegra::Texture::TextureFormat::DXT1:
-        return is_srgb ? PixelFormat::DXT1_SRGB : PixelFormat::DXT1;
-    case Tegra::Texture::TextureFormat::DXT23:
-        return is_srgb ? PixelFormat::DXT23_SRGB : PixelFormat::DXT23;
-    case Tegra::Texture::TextureFormat::DXT45:
-        return is_srgb ? PixelFormat::DXT45_SRGB : PixelFormat::DXT45;
-    case Tegra::Texture::TextureFormat::DXN1:
-        return PixelFormat::DXN1;
-    case Tegra::Texture::TextureFormat::DXN2:
-        switch (component_type) {
-        case Tegra::Texture::ComponentType::UNORM:
-            return PixelFormat::DXN2UNORM;
-        case Tegra::Texture::ComponentType::SNORM:
-            return PixelFormat::DXN2SNORM;
-        }
-        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
-        UNREACHABLE();
-    case Tegra::Texture::TextureFormat::BC7U:
-        return is_srgb ? PixelFormat::BC7U_SRGB : PixelFormat::BC7U;
-    case Tegra::Texture::TextureFormat::BC6H_UF16:
-        return PixelFormat::BC6H_UF16;
-    case Tegra::Texture::TextureFormat::BC6H_SF16:
-        return PixelFormat::BC6H_SF16;
-    case Tegra::Texture::TextureFormat::ASTC_2D_4X4:
-        return is_srgb ? PixelFormat::ASTC_2D_4X4_SRGB : PixelFormat::ASTC_2D_4X4;
-    case Tegra::Texture::TextureFormat::ASTC_2D_5X4:
-        return is_srgb ? PixelFormat::ASTC_2D_5X4_SRGB : PixelFormat::ASTC_2D_5X4;
-    case Tegra::Texture::TextureFormat::ASTC_2D_5X5:
-        return is_srgb ? PixelFormat::ASTC_2D_5X5_SRGB : PixelFormat::ASTC_2D_5X5;
-    case Tegra::Texture::TextureFormat::ASTC_2D_8X8:
-        return is_srgb ? PixelFormat::ASTC_2D_8X8_SRGB : PixelFormat::ASTC_2D_8X8;
-    case Tegra::Texture::TextureFormat::ASTC_2D_8X5:
-        return is_srgb ? PixelFormat::ASTC_2D_8X5_SRGB : PixelFormat::ASTC_2D_8X5;
-    case Tegra::Texture::TextureFormat::R16_G16:
-        switch (component_type) {
-        case Tegra::Texture::ComponentType::FLOAT:
-            return PixelFormat::RG16F;
-        case Tegra::Texture::ComponentType::UNORM:
-            return PixelFormat::RG16;
-        case Tegra::Texture::ComponentType::SNORM:
-            return PixelFormat::RG16S;
-        case Tegra::Texture::ComponentType::UINT:
-            return PixelFormat::RG16UI;
-        case Tegra::Texture::ComponentType::SINT:
-            return PixelFormat::RG16I;
-        }
-        LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type));
-        UNREACHABLE();
-    default:
-        LOG_CRITICAL(HW_GPU, "Unimplemented format={}, component_type={}", static_cast<u32>(format),
-                     static_cast<u32>(component_type));
-        UNREACHABLE();
-    }
-}
-
-ComponentType ComponentTypeFromTexture(Tegra::Texture::ComponentType type) {
-    // TODO(Subv): Implement more component types
-    switch (type) {
-    case Tegra::Texture::ComponentType::UNORM:
-        return ComponentType::UNorm;
-    case Tegra::Texture::ComponentType::FLOAT:
-        return ComponentType::Float;
-    case Tegra::Texture::ComponentType::SNORM:
-        return ComponentType::SNorm;
-    case Tegra::Texture::ComponentType::UINT:
-        return ComponentType::UInt;
-    case Tegra::Texture::ComponentType::SINT:
-        return ComponentType::SInt;
-    default:
-        LOG_CRITICAL(HW_GPU, "Unimplemented component type={}", static_cast<u32>(type));
-        UNREACHABLE();
-    }
-}
-
-ComponentType ComponentTypeFromRenderTarget(Tegra::RenderTargetFormat format) {
-    // TODO(Subv): Implement more render targets
-    switch (format) {
-    case Tegra::RenderTargetFormat::RGBA8_UNORM:
-    case Tegra::RenderTargetFormat::RGBA8_SRGB:
-    case Tegra::RenderTargetFormat::BGRA8_UNORM:
-    case Tegra::RenderTargetFormat::BGRA8_SRGB:
-    case Tegra::RenderTargetFormat::RGB10_A2_UNORM:
-    case Tegra::RenderTargetFormat::R8_UNORM:
-    case Tegra::RenderTargetFormat::RG16_UNORM:
-    case Tegra::RenderTargetFormat::R16_UNORM:
-    case Tegra::RenderTargetFormat::B5G6R5_UNORM:
-    case Tegra::RenderTargetFormat::BGR5A1_UNORM:
-    case Tegra::RenderTargetFormat::RG8_UNORM:
-    case Tegra::RenderTargetFormat::RGBA16_UNORM:
-        return ComponentType::UNorm;
-    case Tegra::RenderTargetFormat::RGBA8_SNORM:
-    case Tegra::RenderTargetFormat::RG16_SNORM:
-    case Tegra::RenderTargetFormat::R16_SNORM:
-    case Tegra::RenderTargetFormat::RG8_SNORM:
-        return ComponentType::SNorm;
-    case Tegra::RenderTargetFormat::RGBA16_FLOAT:
-    case Tegra::RenderTargetFormat::R11G11B10_FLOAT:
-    case Tegra::RenderTargetFormat::RGBA32_FLOAT:
-    case Tegra::RenderTargetFormat::RG32_FLOAT:
-    case Tegra::RenderTargetFormat::RG16_FLOAT:
-    case Tegra::RenderTargetFormat::R16_FLOAT:
-    case Tegra::RenderTargetFormat::R32_FLOAT:
-        return ComponentType::Float;
-    case Tegra::RenderTargetFormat::RGBA32_UINT:
-    case Tegra::RenderTargetFormat::RGBA16_UINT:
-    case Tegra::RenderTargetFormat::RG16_UINT:
-    case Tegra::RenderTargetFormat::R8_UINT:
-    case Tegra::RenderTargetFormat::R16_UINT:
-    case Tegra::RenderTargetFormat::RG32_UINT:
-    case Tegra::RenderTargetFormat::R32_UINT:
-    case Tegra::RenderTargetFormat::RGBA8_UINT:
-        return ComponentType::UInt;
-    case Tegra::RenderTargetFormat::RG16_SINT:
-    case Tegra::RenderTargetFormat::R16_SINT:
-        return ComponentType::SInt;
-    default:
-        LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
-        UNREACHABLE();
-    }
-}
-
-PixelFormat PixelFormatFromGPUPixelFormat(Tegra::FramebufferConfig::PixelFormat format) {
-    switch (format) {
-    case Tegra::FramebufferConfig::PixelFormat::ABGR8:
-        return PixelFormat::ABGR8U;
-    default:
-        LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
-        UNREACHABLE();
-    }
-}
-
-ComponentType ComponentTypeFromDepthFormat(Tegra::DepthFormat format) {
-    switch (format) {
-    case Tegra::DepthFormat::Z16_UNORM:
-    case Tegra::DepthFormat::S8_Z24_UNORM:
-    case Tegra::DepthFormat::Z24_S8_UNORM:
-        return ComponentType::UNorm;
-    case Tegra::DepthFormat::Z32_FLOAT:
-    case Tegra::DepthFormat::Z32_S8_X24_FLOAT:
-        return ComponentType::Float;
-    default:
-        LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
-        UNREACHABLE();
-    }
-}
-
-SurfaceType GetFormatType(PixelFormat pixel_format) {
-    if (static_cast<std::size_t>(pixel_format) <
-        static_cast<std::size_t>(PixelFormat::MaxColorFormat)) {
-        return SurfaceType::ColorTexture;
-    }
-
-    if (static_cast<std::size_t>(pixel_format) <
-        static_cast<std::size_t>(PixelFormat::MaxDepthFormat)) {
-        return SurfaceType::Depth;
-    }
-
-    if (static_cast<std::size_t>(pixel_format) <
-        static_cast<std::size_t>(PixelFormat::MaxDepthStencilFormat)) {
-        return SurfaceType::DepthStencil;
-    }
-
-    // TODO(Subv): Implement the other formats
-    ASSERT(false);
-
-    return SurfaceType::Invalid;
-}
-
-bool IsPixelFormatASTC(PixelFormat format) {
-    switch (format) {
-    case PixelFormat::ASTC_2D_4X4:
-    case PixelFormat::ASTC_2D_5X4:
-    case PixelFormat::ASTC_2D_5X5:
-    case PixelFormat::ASTC_2D_8X8:
-    case PixelFormat::ASTC_2D_8X5:
-    case PixelFormat::ASTC_2D_4X4_SRGB:
-    case PixelFormat::ASTC_2D_5X4_SRGB:
-    case PixelFormat::ASTC_2D_5X5_SRGB:
-    case PixelFormat::ASTC_2D_8X8_SRGB:
-    case PixelFormat::ASTC_2D_8X5_SRGB:
-        return true;
-    default:
-        return false;
-    }
-}
-
-std::pair<u32, u32> GetASTCBlockSize(PixelFormat format) {
-    return {GetDefaultBlockWidth(format), GetDefaultBlockHeight(format)};
-}
-
-bool IsFormatBCn(PixelFormat format) {
-    switch (format) {
-    case PixelFormat::DXT1:
-    case PixelFormat::DXT23:
-    case PixelFormat::DXT45:
-    case PixelFormat::DXN1:
-    case PixelFormat::DXN2SNORM:
-    case PixelFormat::DXN2UNORM:
-    case PixelFormat::BC7U:
-    case PixelFormat::BC6H_UF16:
-    case PixelFormat::BC6H_SF16:
-    case PixelFormat::DXT1_SRGB:
-    case PixelFormat::DXT23_SRGB:
-    case PixelFormat::DXT45_SRGB:
-    case PixelFormat::BC7U_SRGB:
-        return true;
-    }
-    return false;
-}
-
-} // namespace VideoCore::Surface

src/video_core/surface.h

@@ -1,467 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <climits>
-#include <utility>
-#include "common/assert.h"
-#include "common/common_types.h"
-#include "common/logging/log.h"
-#include "video_core/gpu.h"
-#include "video_core/textures/texture.h"
-
-namespace VideoCore::Surface {
-
-enum class PixelFormat {
-    ABGR8U = 0,
-    ABGR8S = 1,
-    ABGR8UI = 2,
-    B5G6R5U = 3,
-    A2B10G10R10U = 4,
-    A1B5G5R5U = 5,
-    R8U = 6,
-    R8UI = 7,
-    RGBA16F = 8,
-    RGBA16U = 9,
-    RGBA16UI = 10,
-    R11FG11FB10F = 11,
-    RGBA32UI = 12,
-    DXT1 = 13,
-    DXT23 = 14,
-    DXT45 = 15,
-    DXN1 = 16, // This is also known as BC4
-    DXN2UNORM = 17,
-    DXN2SNORM = 18,
-    BC7U = 19,
-    BC6H_UF16 = 20,
-    BC6H_SF16 = 21,
-    ASTC_2D_4X4 = 22,
-    G8R8U = 23,
-    G8R8S = 24,
-    BGRA8 = 25,
-    RGBA32F = 26,
-    RG32F = 27,
-    R32F = 28,
-    R16F = 29,
-    R16U = 30,
-    R16S = 31,
-    R16UI = 32,
-    R16I = 33,
-    RG16 = 34,
-    RG16F = 35,
-    RG16UI = 36,
-    RG16I = 37,
-    RG16S = 38,
-    RGB32F = 39,
-    RGBA8_SRGB = 40,
-    RG8U = 41,
-    RG8S = 42,
-    RG32UI = 43,
-    R32UI = 44,
-    ASTC_2D_8X8 = 45,
-    ASTC_2D_8X5 = 46,
-    ASTC_2D_5X4 = 47,
-    BGRA8_SRGB = 48,
-    DXT1_SRGB = 49,
-    DXT23_SRGB = 50,
-    DXT45_SRGB = 51,
-    BC7U_SRGB = 52,
-    ASTC_2D_4X4_SRGB = 53,
-    ASTC_2D_8X8_SRGB = 54,
-    ASTC_2D_8X5_SRGB = 55,
-    ASTC_2D_5X4_SRGB = 56,
-    ASTC_2D_5X5 = 57,
-    ASTC_2D_5X5_SRGB = 58,
-
-    MaxColorFormat,
-
-    // Depth formats
-    Z32F = 59,
-    Z16 = 60,
-
-    MaxDepthFormat,
-
-    // DepthStencil formats
-    Z24S8 = 61,
-    S8Z24 = 62,
-    Z32FS8 = 63,
-
-    MaxDepthStencilFormat,
-
-    Max = MaxDepthStencilFormat,
-    Invalid = 255,
-};
-
-static constexpr std::size_t MaxPixelFormat = static_cast<std::size_t>(PixelFormat::Max);
-
-enum class ComponentType {
-    Invalid = 0,
-    SNorm = 1,
-    UNorm = 2,
-    SInt = 3,
-    UInt = 4,
-    Float = 5,
-};
-
-enum class SurfaceType {
-    ColorTexture = 0,
-    Depth = 1,
-    DepthStencil = 2,
-    Fill = 3,
-    Invalid = 4,
-};
-
-enum class SurfaceTarget {
-    Texture1D,
-    Texture2D,
-    Texture3D,
-    Texture1DArray,
-    Texture2DArray,
-    TextureCubemap,
-    TextureCubeArray,
-};
-
-/**
- * Gets the compression factor for the specified PixelFormat. This applies to just the
- * "compressed width" and "compressed height", not the overall compression factor of a
- * compressed image. This is used for maintaining proper surface sizes for compressed
- * texture formats.
- */
-static constexpr u32 GetCompressionFactor(PixelFormat format) {
-    if (format == PixelFormat::Invalid)
-        return 0;
-
-    constexpr std::array<u32, MaxPixelFormat> compression_factor_table = {{
-        1, // ABGR8U
-        1, // ABGR8S
-        1, // ABGR8UI
-        1, // B5G6R5U
-        1, // A2B10G10R10U
-        1, // A1B5G5R5U
-        1, // R8U
-        1, // R8UI
-        1, // RGBA16F
-        1, // RGBA16U
-        1, // RGBA16UI
-        1, // R11FG11FB10F
-        1, // RGBA32UI
-        4, // DXT1
-        4, // DXT23
-        4, // DXT45
-        4, // DXN1
-        4, // DXN2UNORM
-        4, // DXN2SNORM
-        4, // BC7U
-        4, // BC6H_UF16
-        4, // BC6H_SF16
-        4, // ASTC_2D_4X4
-        1, // G8R8U
-        1, // G8R8S
-        1, // BGRA8
-        1, // RGBA32F
-        1, // RG32F
-        1, // R32F
-        1, // R16F
-        1, // R16U
-        1, // R16S
-        1, // R16UI
-        1, // R16I
-        1, // RG16
-        1, // RG16F
-        1, // RG16UI
-        1, // RG16I
-        1, // RG16S
-        1, // RGB32F
-        1, // RGBA8_SRGB
-        1, // RG8U
-        1, // RG8S
-        1, // RG32UI
-        1, // R32UI
-        4, // ASTC_2D_8X8
-        4, // ASTC_2D_8X5
-        4, // ASTC_2D_5X4
-        1, // BGRA8_SRGB
-        4, // DXT1_SRGB
-        4, // DXT23_SRGB
-        4, // DXT45_SRGB
-        4, // BC7U_SRGB
-        4, // ASTC_2D_4X4_SRGB
-        4, // ASTC_2D_8X8_SRGB
-        4, // ASTC_2D_8X5_SRGB
-        4, // ASTC_2D_5X4_SRGB
-        4, // ASTC_2D_5X5
-        4, // ASTC_2D_5X5_SRGB
-        1, // Z32F
-        1, // Z16
-        1, // Z24S8
-        1, // S8Z24
-        1, // Z32FS8
-    }};
-
-    ASSERT(static_cast<std::size_t>(format) < compression_factor_table.size());
-    return compression_factor_table[static_cast<std::size_t>(format)];
-}
-
-static constexpr u32 GetDefaultBlockWidth(PixelFormat format) {
-    if (format == PixelFormat::Invalid)
-        return 0;
-    constexpr std::array<u32, MaxPixelFormat> block_width_table = {{
-        1, // ABGR8U
-        1, // ABGR8S
-        1, // ABGR8UI
-        1, // B5G6R5U
-        1, // A2B10G10R10U
-        1, // A1B5G5R5U
-        1, // R8U
-        1, // R8UI
-        1, // RGBA16F
-        1, // RGBA16U
-        1, // RGBA16UI
-        1, // R11FG11FB10F
-        1, // RGBA32UI
-        4, // DXT1
-        4, // DXT23
-        4, // DXT45
-        4, // DXN1
-        4, // DXN2UNORM
-        4, // DXN2SNORM
-        4, // BC7U
-        4, // BC6H_UF16
-        4, // BC6H_SF16
-        4, // ASTC_2D_4X4
-        1, // G8R8U
-        1, // G8R8S
-        1, // BGRA8
-        1, // RGBA32F
-        1, // RG32F
-        1, // R32F
-        1, // R16F
-        1, // R16U
-        1, // R16S
-        1, // R16UI
-        1, // R16I
-        1, // RG16
-        1, // RG16F
-        1, // RG16UI
-        1, // RG16I
-        1, // RG16S
-        1, // RGB32F
-        1, // RGBA8_SRGB
-        1, // RG8U
-        1, // RG8S
-        1, // RG32UI
-        1, // R32UI
-        8, // ASTC_2D_8X8
-        8, // ASTC_2D_8X5
-        5, // ASTC_2D_5X4
-        1, // BGRA8_SRGB
-        4, // DXT1_SRGB
-        4, // DXT23_SRGB
-        4, // DXT45_SRGB
-        4, // BC7U_SRGB
-        4, // ASTC_2D_4X4_SRGB
-        8, // ASTC_2D_8X8_SRGB
-        8, // ASTC_2D_8X5_SRGB
-        5, // ASTC_2D_5X4_SRGB
-        5, // ASTC_2D_5X5
-        5, // ASTC_2D_5X5_SRGB
-        1, // Z32F
-        1, // Z16
-        1, // Z24S8
-        1, // S8Z24
-        1, // Z32FS8
-    }};
-    ASSERT(static_cast<std::size_t>(format) < block_width_table.size());
-    return block_width_table[static_cast<std::size_t>(format)];
-}
-
-static constexpr u32 GetDefaultBlockHeight(PixelFormat format) {
-    if (format == PixelFormat::Invalid)
-        return 0;
-
-    constexpr std::array<u32, MaxPixelFormat> block_height_table = {{
-        1, // ABGR8U
-        1, // ABGR8S
-        1, // ABGR8UI
-        1, // B5G6R5U
-        1, // A2B10G10R10U
-        1, // A1B5G5R5U
-        1, // R8U
-        1, // R8UI
-        1, // RGBA16F
-        1, // RGBA16U
-        1, // RGBA16UI
-        1, // R11FG11FB10F
-        1, // RGBA32UI
-        4, // DXT1
-        4, // DXT23
-        4, // DXT45
-        4, // DXN1
-        4, // DXN2UNORM
-        4, // DXN2SNORM
-        4, // BC7U
-        4, // BC6H_UF16
-        4, // BC6H_SF16
-        4, // ASTC_2D_4X4
-        1, // G8R8U
-        1, // G8R8S
-        1, // BGRA8
-        1, // RGBA32F
-        1, // RG32F
-        1, // R32F
-        1, // R16F
-        1, // R16U
-        1, // R16S
-        1, // R16UI
-        1, // R16I
-        1, // RG16
-        1, // RG16F
-        1, // RG16UI
-        1, // RG16I
-        1, // RG16S
-        1, // RGB32F
-        1, // RGBA8_SRGB
-        1, // RG8U
-        1, // RG8S
-        1, // RG32UI
-        1, // R32UI
-        8, // ASTC_2D_8X8
-        5, // ASTC_2D_8X5
-        4, // ASTC_2D_5X4
-        1, // BGRA8_SRGB
-        4, // DXT1_SRGB
-        4, // DXT23_SRGB
-        4, // DXT45_SRGB
-        4, // BC7U_SRGB
-        4, // ASTC_2D_4X4_SRGB
-        8, // ASTC_2D_8X8_SRGB
-        5, // ASTC_2D_8X5_SRGB
-        4, // ASTC_2D_5X4_SRGB
-        5, // ASTC_2D_5X5
-        5, // ASTC_2D_5X5_SRGB
-        1, // Z32F
-        1, // Z16
-        1, // Z24S8
-        1, // S8Z24
-        1, // Z32FS8
-    }};
-
-    ASSERT(static_cast<std::size_t>(format) < block_height_table.size());
-    return block_height_table[static_cast<std::size_t>(format)];
-}
-
-static constexpr u32 GetFormatBpp(PixelFormat format) {
-    if (format == PixelFormat::Invalid)
-        return 0;
-
-    constexpr std::array<u32, MaxPixelFormat> bpp_table = {{
-        32,  // ABGR8U
-        32,  // ABGR8S
-        32,  // ABGR8UI
-        16,  // B5G6R5U
-        32,  // A2B10G10R10U
-        16,  // A1B5G5R5U
-        8,   // R8U
-        8,   // R8UI
-        64,  // RGBA16F
-        64,  // RGBA16U
-        64,  // RGBA16UI
-        32,  // R11FG11FB10F
-        128, // RGBA32UI
-        64,  // DXT1
-        128, // DXT23
-        128, // DXT45
-        64,  // DXN1
-        128, // DXN2UNORM
-        128, // DXN2SNORM
-        128, // BC7U
-        128, // BC6H_UF16
-        128, // BC6H_SF16
-        128, // ASTC_2D_4X4
-        16,  // G8R8U
-        16,  // G8R8S
-        32,  // BGRA8
-        128, // RGBA32F
-        64,  // RG32F
-        32,  // R32F
-        16,  // R16F
-        16,  // R16U
-        16,  // R16S
-        16,  // R16UI
-        16,  // R16I
-        32,  // RG16
-        32,  // RG16F
-        32,  // RG16UI
-        32,  // RG16I
-        32,  // RG16S
-        96,  // RGB32F
-        32,  // RGBA8_SRGB
-        16,  // RG8U
-        16,  // RG8S
-        64,  // RG32UI
-        32,  // R32UI
-        128, // ASTC_2D_8X8
-        128, // ASTC_2D_8X5
-        128, // ASTC_2D_5X4
-        32,  // BGRA8_SRGB
-        64,  // DXT1_SRGB
-        128, // DXT23_SRGB
-        128, // DXT45_SRGB
-        128, // BC7U
-        128, // ASTC_2D_4X4_SRGB
-        128, // ASTC_2D_8X8_SRGB
-        128, // ASTC_2D_8X5_SRGB
-        128, // ASTC_2D_5X4_SRGB
-        128, // ASTC_2D_5X5
-        128, // ASTC_2D_5X5_SRGB
-        32,  // Z32F
-        16,  // Z16
-        32,  // Z24S8
-        32,  // S8Z24
-        64,  // Z32FS8
-    }};
-
-    ASSERT(static_cast<std::size_t>(format) < bpp_table.size());
-    return bpp_table[static_cast<std::size_t>(format)];
-}
-
-/// Returns the sizer in bytes of the specified pixel format
-static constexpr u32 GetBytesPerPixel(PixelFormat pixel_format) {
-    if (pixel_format == PixelFormat::Invalid) {
-        return 0;
-    }
-    return GetFormatBpp(pixel_format) / CHAR_BIT;
-}
-
-SurfaceTarget SurfaceTargetFromTextureType(Tegra::Texture::TextureType texture_type);
-
-bool SurfaceTargetIsLayered(SurfaceTarget target);
-
-PixelFormat PixelFormatFromDepthFormat(Tegra::DepthFormat format);
-
-PixelFormat PixelFormatFromRenderTargetFormat(Tegra::RenderTargetFormat format);
-
-PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
-                                         Tegra::Texture::ComponentType component_type,
-                                         bool is_srgb);
-
-ComponentType ComponentTypeFromTexture(Tegra::Texture::ComponentType type);
-
-ComponentType ComponentTypeFromRenderTarget(Tegra::RenderTargetFormat format);
-
-PixelFormat PixelFormatFromGPUPixelFormat(Tegra::FramebufferConfig::PixelFormat format);
-
-ComponentType ComponentTypeFromDepthFormat(Tegra::DepthFormat format);
-
-SurfaceType GetFormatType(PixelFormat pixel_format);
-
-bool IsPixelFormatASTC(PixelFormat format);
-
-std::pair<u32, u32> GetASTCBlockSize(PixelFormat format);
-
-/// Returns true if the specified PixelFormat is a BCn format, e.g. DXT or DXN
-bool IsFormatBCn(PixelFormat format);
-
-} // namespace VideoCore::Surface

src/video_core/textures/astc.cpp

@@ -1598,29 +1598,27 @@ static void DecompressBlock(uint8_t inBuf[16], const uint32_t blockWidth,
 namespace Tegra::Texture::ASTC {
 
 std::vector<uint8_t> Decompress(std::vector<uint8_t>& data, uint32_t width, uint32_t height,
-                                uint32_t depth, uint32_t block_width, uint32_t block_height) {
+                                uint32_t block_width, uint32_t block_height) {
     uint32_t blockIdx = 0;
-    std::vector<uint8_t> outData(height * width * depth * 4);
-    for (uint32_t k = 0; k < depth; k++) {
-        for (uint32_t j = 0; j < height; j += block_height) {
-            for (uint32_t i = 0; i < width; i += block_width) {
+    std::vector<uint8_t> outData(height * width * 4);
+    for (uint32_t j = 0; j < height; j += block_height) {
+        for (uint32_t i = 0; i < width; i += block_width) {
 
-                uint8_t* blockPtr = data.data() + blockIdx * 16;
+            uint8_t* blockPtr = data.data() + blockIdx * 16;
 
-                // Blocks can be at most 12x12
-                uint32_t uncompData[144];
-                ASTCC::DecompressBlock(blockPtr, block_width, block_height, uncompData);
+            // Blocks can be at most 12x12
+            uint32_t uncompData[144];
+            ASTCC::DecompressBlock(blockPtr, block_width, block_height, uncompData);
 
-                uint32_t decompWidth = std::min(block_width, width - i);
-                uint32_t decompHeight = std::min(block_height, height - j);
+            uint32_t decompWidth = std::min(block_width, width - i);
+            uint32_t decompHeight = std::min(block_height, height - j);
 
-                uint8_t* outRow = outData.data() + (j * width + i) * 4;
-                for (uint32_t jj = 0; jj < decompHeight; jj++) {
-                    memcpy(outRow + jj * width * 4, uncompData + jj * block_width, decompWidth * 4);
-                }
-
-                blockIdx++;
+            uint8_t* outRow = outData.data() + (j * width + i) * 4;
+            for (uint32_t jj = 0; jj < decompHeight; jj++) {
+                memcpy(outRow + jj * width * 4, uncompData + jj * block_width, decompWidth * 4);
             }
+
+            blockIdx++;
         }
     }
 

src/video_core/textures/astc.h

@@ -10,6 +10,6 @@
 namespace Tegra::Texture::ASTC {
 
 std::vector<uint8_t> Decompress(std::vector<uint8_t>& data, uint32_t width, uint32_t height,
-                                uint32_t depth, uint32_t block_width, uint32_t block_height);
+                                uint32_t block_width, uint32_t block_height);
 
 } // namespace Tegra::Texture::ASTC

src/video_core/textures/decoders.cpp

@@ -227,14 +227,12 @@ u32 BytesPerPixel(TextureFormat format) {
     }
 }
 
-std::vector<u8> UnswizzleTexture(VAddr address, u32 tile_size_x, u32 tile_size_y,
-                                 u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
-                                 u32 block_height, u32 block_depth) {
+std::vector<u8> UnswizzleTexture(VAddr address, u32 tile_size, u32 bytes_per_pixel, u32 width,
+                                 u32 height, u32 depth, u32 block_height, u32 block_depth) {
     std::vector<u8> unswizzled_data(width * height * depth * bytes_per_pixel);
-    CopySwizzledData((width + tile_size_x - 1) / tile_size_x,
-                     (height + tile_size_y - 1) / tile_size_y, depth, bytes_per_pixel,
-                     bytes_per_pixel, Memory::GetPointer(address), unswizzled_data.data(), true,
-                     block_height, block_depth);
+    CopySwizzledData(width / tile_size, height / tile_size, depth, bytes_per_pixel, bytes_per_pixel,
+                     Memory::GetPointer(address), unswizzled_data.data(), true, block_height,
+                     block_depth);
     return unswizzled_data;
 }
 

src/video_core/textures/decoders.h

@@ -10,17 +10,11 @@
 
 namespace Tegra::Texture {
 
-// GOBSize constant. Calculated by 64 bytes in x multiplied by 8 y coords, represents
-// an small rect of (64/bytes_per_pixel)X8.
-inline std::size_t GetGOBSize() {
-    return 512;
-}
-
 /**
  * Unswizzles a swizzled texture without changing its format.
  */
-std::vector<u8> UnswizzleTexture(VAddr address, u32 tile_size_x, u32 tile_size_y,
-                                 u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
+std::vector<u8> UnswizzleTexture(VAddr address, u32 tile_size, u32 bytes_per_pixel, u32 width,
+                                 u32 height, u32 depth,
                                  u32 block_height = TICEntry::DefaultBlockHeight,
                                  u32 block_depth = TICEntry::DefaultBlockHeight);
 

src/video_core/utils.h

@@ -161,4 +161,30 @@ static inline void MortonCopyPixels128(u32 width, u32 height, u32 bytes_per_pixe
     }
 }
 
+static void LabelGLObject(GLenum identifier, GLuint handle, VAddr addr,
+                          std::string extra_info = "") {
+    if (!GLAD_GL_KHR_debug) {
+        return; // We don't need to throw an error as this is just for debugging
+    }
+    const std::string nice_addr = fmt::format("0x{:016x}", addr);
+    std::string object_label;
+
+    if (extra_info.empty()) {
+        switch (identifier) {
+        case GL_TEXTURE:
+            object_label = "Texture@" + nice_addr;
+            break;
+        case GL_PROGRAM:
+            object_label = "Shader@" + nice_addr;
+            break;
+        default:
+            object_label = fmt::format("Object(0x{:x})@{}", identifier, nice_addr);
+            break;
+        }
+    } else {
+        object_label = extra_info + '@' + nice_addr;
+    }
+    glObjectLabel(identifier, handle, -1, static_cast<const GLchar*>(object_label.c_str()));
+}
+
 } // namespace VideoCore

src/web_service/telemetry_json.cpp

@@ -102,27 +102,16 @@ void TelemetryJson::Complete() {
     impl->SerializeSection(Telemetry::FieldType::App, "App");
     impl->SerializeSection(Telemetry::FieldType::Session, "Session");
     impl->SerializeSection(Telemetry::FieldType::Performance, "Performance");
+    impl->SerializeSection(Telemetry::FieldType::UserFeedback, "UserFeedback");
     impl->SerializeSection(Telemetry::FieldType::UserConfig, "UserConfig");
     impl->SerializeSection(Telemetry::FieldType::UserSystem, "UserSystem");
 
     auto content = impl->TopSection().dump();
     // Send the telemetry async but don't handle the errors since they were written to the log
-    Common::DetachedTasks::AddTask([host{impl->host}, content]() {
-        Client{host, "", ""}.PostJson("/telemetry", content, true);
-    });
-}
-
-bool TelemetryJson::SubmitTestcase() {
-    impl->SerializeSection(Telemetry::FieldType::App, "App");
-    impl->SerializeSection(Telemetry::FieldType::Session, "Session");
-    impl->SerializeSection(Telemetry::FieldType::UserFeedback, "UserFeedback");
-    impl->SerializeSection(Telemetry::FieldType::UserSystem, "UserSystem");
-
-    auto content = impl->TopSection().dump();
-    Client client(impl->host, impl->username, impl->token);
-    auto value = client.PostJson("/gamedb/testcase", content, false);
-
-    return value.result_code == Common::WebResult::Code::Success;
+    Common::DetachedTasks::AddTask(
+        [host{impl->host}, username{impl->username}, token{impl->token}, content]() {
+            Client{host, username, token}.PostJson("/telemetry", content, true);
+        });
 }
 
 } // namespace WebService

src/web_service/telemetry_json.h

@@ -35,7 +35,6 @@ public:
     void Visit(const Telemetry::Field<std::chrono::microseconds>& field) override;
 
     void Complete() override;
-    bool SubmitTestcase() override;
 
 private:
     struct Impl;

src/yuzu/CMakeLists.txt

@@ -56,8 +56,6 @@ add_executable(yuzu
     main.h
     ui_settings.cpp
     ui_settings.h
-    util/limitable_input_dialog.cpp
-    util/limitable_input_dialog.h
     util/spinbox.cpp
     util/spinbox.h
     util/util.cpp

src/yuzu/compatdb.cpp

@@ -5,7 +5,6 @@
 #include <QButtonGroup>
 #include <QMessageBox>
 #include <QPushButton>
-#include <QtConcurrent/qtconcurrentrun.h>
 #include "common/logging/log.h"
 #include "common/telemetry.h"
 #include "core/core.h"
@@ -24,8 +23,6 @@ CompatDB::CompatDB(QWidget* parent)
     connect(ui->radioButton_IntroMenu, &QRadioButton::clicked, this, &CompatDB::EnableNext);
     connect(ui->radioButton_WontBoot, &QRadioButton::clicked, this, &CompatDB::EnableNext);
     connect(button(NextButton), &QPushButton::clicked, this, &CompatDB::Submit);
-    connect(&testcase_watcher, &QFutureWatcher<bool>::finished, this,
-            &CompatDB::OnTestcaseSubmitted);
 }
 
 CompatDB::~CompatDB() = default;
@@ -51,38 +48,18 @@ void CompatDB::Submit() {
         }
         break;
     case CompatDBPage::Final:
-        back();
         LOG_DEBUG(Frontend, "Compatibility Rating: {}", compatibility->checkedId());
         Core::Telemetry().AddField(Telemetry::FieldType::UserFeedback, "Compatibility",
                                    compatibility->checkedId());
-
-        button(NextButton)->setEnabled(false);
-        button(NextButton)->setText(tr("Submitting"));
+        // older versions of QT don't support the "NoCancelButtonOnLastPage" option, this is a
+        // workaround
         button(QWizard::CancelButton)->setVisible(false);
-
-        testcase_watcher.setFuture(QtConcurrent::run(
-            [this]() { return Core::System::GetInstance().TelemetrySession().SubmitTestcase(); }));
         break;
     default:
         LOG_ERROR(Frontend, "Unexpected page: {}", currentId());
     }
 }
 
-void CompatDB::OnTestcaseSubmitted() {
-    if (!testcase_watcher.result()) {
-        QMessageBox::critical(this, tr("Communication error"),
-                              tr("An error occured while sending the Testcase"));
-        button(NextButton)->setEnabled(true);
-        button(NextButton)->setText(tr("Next"));
-        button(QWizard::CancelButton)->setVisible(true);
-    } else {
-        next();
-        // older versions of QT don't support the "NoCancelButtonOnLastPage" option, this is a
-        // workaround
-        button(QWizard::CancelButton)->setVisible(false);
-    }
-}
-
 void CompatDB::EnableNext() {
     button(NextButton)->setEnabled(true);
 }

src/yuzu/compatdb.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <memory>
-#include <QFutureWatcher>
 #include <QWizard>
 
 namespace Ui {
@@ -20,11 +19,8 @@ public:
     ~CompatDB();
 
 private:
-    QFutureWatcher<bool> testcase_watcher;
-
     std::unique_ptr<Ui::CompatDB> ui;
 
     void Submit();
-    void OnTestcaseSubmitted();
     void EnableNext();
 };

src/yuzu/configuration/configure_system.cpp

@@ -6,20 +6,20 @@
 #include <QFileDialog>
 #include <QGraphicsItem>
 #include <QGraphicsScene>
-#include <QHeaderView>
+#include <QInputDialog>
 #include <QMessageBox>
 #include <QStandardItemModel>
 #include <QTreeView>
 #include <QVBoxLayout>
-#include "common/assert.h"
-#include "common/file_util.h"
+#include "common/common_paths.h"
+#include "common/logging/backend.h"
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"
 #include "ui_configure_system.h"
 #include "yuzu/configuration/configure_system.h"
-#include "yuzu/util/limitable_input_dialog.h"
+#include "yuzu/main.h"
 
 namespace {
 constexpr std::array<int, 12> days_in_month = {{
@@ -78,17 +78,11 @@ QPixmap GetIcon(Service::Account::UUID uuid) {
 
     if (!icon) {
         icon.fill(Qt::black);
-        icon.loadFromData(backup_jpeg.data(), static_cast<u32>(backup_jpeg.size()));
+        icon.loadFromData(backup_jpeg.data(), backup_jpeg.size());
     }
 
     return icon.scaled(64, 64, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 }
-
-QString GetProfileUsernameFromUser(QWidget* parent, const QString& description_text) {
-    return LimitableInputDialog::GetText(parent, ConfigureSystem::tr("Enter Username"),
-                                         description_text, 1,
-                                         static_cast<int>(Service::Account::profile_username_size));
-}
 } // Anonymous namespace
 
 ConfigureSystem::ConfigureSystem(QWidget* parent)
@@ -250,13 +244,15 @@ void ConfigureSystem::SelectUser(const QModelIndex& index) {
 }
 
 void ConfigureSystem::AddUser() {
-    const auto username =
-        GetProfileUsernameFromUser(this, tr("Enter a username for the new user:"));
-    if (username.isEmpty()) {
-        return;
-    }
-
     const auto uuid = Service::Account::UUID::Generate();
+
+    bool ok = false;
+    const auto username =
+        QInputDialog::getText(this, tr("Enter Username"), tr("Enter a username for the new user:"),
+                              QLineEdit::Normal, QString(), &ok);
+    if (!ok)
+        return;
+
     profile_manager->CreateNewUser(uuid, username.toStdString());
 
     item_model->appendRow(new QStandardItem{GetIcon(uuid), FormatUserEntryText(username, uuid)});
@@ -271,14 +267,23 @@ void ConfigureSystem::RenameUser() {
     if (!profile_manager->GetProfileBase(*uuid, profile))
         return;
 
-    const auto new_username = GetProfileUsernameFromUser(this, tr("Enter a new username:"));
-    if (new_username.isEmpty()) {
-        return;
-    }
+    bool ok = false;
+    const auto old_username = GetAccountUsername(*profile_manager, *uuid);
+    const auto new_username =
+        QInputDialog::getText(this, tr("Enter Username"), tr("Enter a new username:"),
+                              QLineEdit::Normal, old_username, &ok);
+
+    if (!ok)
+        return;
 
-    const auto username_std = new_username.toStdString();
     std::fill(profile.username.begin(), profile.username.end(), '\0');
-    std::copy(username_std.begin(), username_std.end(), profile.username.begin());
+    const auto username_std = new_username.toStdString();
+    if (username_std.size() > profile.username.size()) {
+        std::copy_n(username_std.begin(), std::min(profile.username.size(), username_std.size()),
+                    profile.username.begin());
+    } else {
+        std::copy(username_std.begin(), username_std.end(), profile.username.begin());
+    }
 
     profile_manager->SetProfileBase(*uuid, profile);
 

src/yuzu/debugger/graphics/graphics_surface.cpp

@@ -386,9 +386,9 @@ void GraphicsSurfaceWidget::OnUpdate() {
 
     // TODO(bunnei): Will not work with BCn formats that swizzle 4x4 tiles.
     // Needs to be fixed if we plan to use this feature more, otherwise we may remove it.
-    auto unswizzled_data = Tegra::Texture::UnswizzleTexture(
-        *address, 1, 1, Tegra::Texture::BytesPerPixel(surface_format), surface_width,
-        surface_height, 1U);
+    auto unswizzled_data =
+        Tegra::Texture::UnswizzleTexture(*address, 1, Tegra::Texture::BytesPerPixel(surface_format),
+                                         surface_width, surface_height, 1U);
 
     auto texture_data = Tegra::Texture::DecodeTexture(unswizzled_data, surface_format,
                                                       surface_width, surface_height);

src/yuzu/debugger/wait_tree.h

@@ -11,6 +11,7 @@
 #include <QAbstractItemModel>
 #include <QDockWidget>
 #include <QTreeView>
+#include <boost/container/flat_set.hpp>
 #include "common/common_types.h"
 #include "core/hle/kernel/object.h"
 

src/yuzu/main.cpp

@@ -142,9 +142,6 @@ static void InitializeLogging() {
     const std::string& log_dir = FileUtil::GetUserPath(FileUtil::UserPath::LogDir);
     FileUtil::CreateFullPath(log_dir);
     Log::AddBackend(std::make_unique<Log::FileBackend>(log_dir + LOG_FILE));
-#ifdef _WIN32
-    Log::AddBackend(std::make_unique<Log::DebuggerBackend>());
-#endif
 }
 
 GMainWindow::GMainWindow()
@@ -457,7 +454,6 @@ void GMainWindow::ConnectMenuEvents() {
     connect(ui.action_Fullscreen, &QAction::triggered, this, &GMainWindow::ToggleFullscreen);
 
     // Help
-    connect(ui.action_Open_yuzu_Folder, &QAction::triggered, this, &GMainWindow::OnOpenYuzuFolder);
     connect(ui.action_Rederive, &QAction::triggered, this,
             std::bind(&GMainWindow::OnReinitializeKeys, this, ReinitializeKeyBehavior::Warning));
     connect(ui.action_About, &QAction::triggered, this, &GMainWindow::OnAbout);
@@ -1378,11 +1374,6 @@ void GMainWindow::OnLoadAmiibo() {
     }
 }
 
-void GMainWindow::OnOpenYuzuFolder() {
-    QDesktopServices::openUrl(QUrl::fromLocalFile(
-        QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::UserDir))));
-}
-
 void GMainWindow::OnAbout() {
     AboutDialog aboutDialog(this);
     aboutDialog.exec();
@@ -1541,7 +1532,7 @@ void GMainWindow::OnReinitializeKeys(ReinitializeKeyBehavior behavior) {
                    "derivation. It will be attempted but may not complete.<br><br>") +
                     errors +
                     tr("<br><br>You can get all of these and dump all of your games easily by "
-                       "following <a href='https://yuzu-emu.org/help/quickstart/'>the "
+                       "following <a href='https://yuzu-emu.org/help/quickstart/quickstart/'>the "
                        "quickstart guide</a>. Alternatively, you can use another method of dumping "
                        "to obtain all of your keys."));
         }

src/yuzu/main.h

@@ -167,7 +167,6 @@ private slots:
     void OnMenuRecentFile();
     void OnConfigure();
     void OnLoadAmiibo();
-    void OnOpenYuzuFolder();
     void OnAbout();
     void OnToggleFilterBar();
     void OnDisplayTitleBars(bool);

src/yuzu/main.ui

@@ -110,7 +110,6 @@
      <string>&amp;Help</string>
     </property>
     <addaction name="action_Report_Compatibility"/>
-    <addaction name="action_Open_yuzu_Folder" />
     <addaction name="separator"/>
     <addaction name="action_About"/>
    </widget>
@@ -278,11 +277,6 @@
        <bool>false</bool>
      </property>
    </action>
-   <action name="action_Open_yuzu_Folder">
-     <property name="text">
-       <string>Open yuzu Folder</string>
-     </property>
-   </action>
   </widget>
  <resources/>
  <connections/>

src/yuzu/util/limitable_input_dialog.cpp

@@ -1,59 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <QDialogButtonBox>
-#include <QLabel>
-#include <QLineEdit>
-#include <QPushButton>
-#include <QVBoxLayout>
-#include "yuzu/util/limitable_input_dialog.h"
-
-LimitableInputDialog::LimitableInputDialog(QWidget* parent) : QDialog{parent} {
-    CreateUI();
-    ConnectEvents();
-}
-
-LimitableInputDialog::~LimitableInputDialog() = default;
-
-void LimitableInputDialog::CreateUI() {
-    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
-
-    text_label = new QLabel(this);
-    text_entry = new QLineEdit(this);
-    buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
-
-    auto* const layout = new QVBoxLayout;
-    layout->addWidget(text_label);
-    layout->addWidget(text_entry);
-    layout->addWidget(buttons);
-
-    setLayout(layout);
-}
-
-void LimitableInputDialog::ConnectEvents() {
-    connect(buttons, &QDialogButtonBox::accepted, this, &QDialog::accept);
-    connect(buttons, &QDialogButtonBox::rejected, this, &QDialog::reject);
-}
-
-QString LimitableInputDialog::GetText(QWidget* parent, const QString& title, const QString& text,
-                                      int min_character_limit, int max_character_limit) {
-    Q_ASSERT(min_character_limit <= max_character_limit);
-
-    LimitableInputDialog dialog{parent};
-    dialog.setWindowTitle(title);
-    dialog.text_label->setText(text);
-    dialog.text_entry->setMaxLength(max_character_limit);
-
-    auto* const ok_button = dialog.buttons->button(QDialogButtonBox::Ok);
-    ok_button->setEnabled(false);
-    connect(dialog.text_entry, &QLineEdit::textEdited, [&](const QString& new_text) {
-        ok_button->setEnabled(new_text.length() >= min_character_limit);
-    });
-
-    if (dialog.exec() != QDialog::Accepted) {
-        return {};
-    }
-
-    return dialog.text_entry->text();
-}

src/yuzu/util/limitable_input_dialog.h

@@ -1,31 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <QDialog>
-
-class QDialogButtonBox;
-class QLabel;
-class QLineEdit;
-
-/// A QDialog that functions similarly to QInputDialog, however, it allows
-/// restricting the minimum and total number of characters that can be entered.
-class LimitableInputDialog final : public QDialog {
-    Q_OBJECT
-public:
-    explicit LimitableInputDialog(QWidget* parent = nullptr);
-    ~LimitableInputDialog() override;
-
-    static QString GetText(QWidget* parent, const QString& title, const QString& text,
-                           int min_character_limit, int max_character_limit);
-
-private:
-    void CreateUI();
-    void ConnectEvents();
-
-    QLabel* text_label;
-    QLineEdit* text_entry;
-    QDialogButtonBox* buttons;
-};

src/yuzu_cmd/yuzu.cpp

@@ -76,9 +76,6 @@ static void InitializeLogging() {
     const std::string& log_dir = FileUtil::GetUserPath(FileUtil::UserPath::LogDir);
     FileUtil::CreateFullPath(log_dir);
     Log::AddBackend(std::make_unique<Log::FileBackend>(log_dir + LOG_FILE));
-#ifdef _WIN32
-    Log::AddBackend(std::make_unique<Log::DebuggerBackend>());
-#endif
 }
 
 /// Application entry point