core: Mark unused fields as [[maybe_unused]]

Merge pull request #5143 from comex/xx-users-size
yuzu_cmd: Remove 'users_size'
2020-12-06 18:36:10 -05:00 · 2020-12-06 19:34:53 -03:00 · 2020-12-06 19:34:24 -03:00 · 2020-12-06 01:53:02 -08:00 · 2020-12-06 01:22:43 -08:00 · 2020-12-06 00:45:23 -08:00
92 changed files with 638 additions and 612 deletions
@@ -30,6 +30,7 @@ public:
        params.rate = sample_rate;
        params.channels = num_channels;
        params.format = CUBEB_SAMPLE_S16NE;
+        params.prefs = CUBEB_STREAM_PREF_PERSIST;
        switch (num_channels) {
        case 1:
            params.layout = CUBEB_LAYOUT_MONO;
@@ -11,25 +11,25 @@

 namespace Common::X64 {

-constexpr std::size_t RegToIndex(const Xbyak::Reg& reg) {
+constexpr size_t RegToIndex(const Xbyak::Reg& reg) {
    using Kind = Xbyak::Reg::Kind;
    ASSERT_MSG((reg.getKind() & (Kind::REG | Kind::XMM)) != 0,
               "RegSet only support GPRs and XMM registers.");
    ASSERT_MSG(reg.getIdx() < 16, "RegSet only supports XXM0-15.");
-    return reg.getIdx() + (reg.getKind() == Kind::REG ? 0 : 16);
+    return static_cast<size_t>(reg.getIdx()) + (reg.getKind() == Kind::REG ? 0 : 16);
 }

-constexpr Xbyak::Reg64 IndexToReg64(std::size_t reg_index) {
+constexpr Xbyak::Reg64 IndexToReg64(size_t reg_index) {
    ASSERT(reg_index < 16);
    return Xbyak::Reg64(static_cast<int>(reg_index));
 }

-constexpr Xbyak::Xmm IndexToXmm(std::size_t reg_index) {
+constexpr Xbyak::Xmm IndexToXmm(size_t reg_index) {
    ASSERT(reg_index >= 16 && reg_index < 32);
    return Xbyak::Xmm(static_cast<int>(reg_index - 16));
 }

-constexpr Xbyak::Reg IndexToReg(std::size_t reg_index) {
+constexpr Xbyak::Reg IndexToReg(size_t reg_index) {
    if (reg_index < 16) {
        return IndexToReg64(reg_index);
    } else {
@@ -182,7 +182,7 @@ inline size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::b
                                              size_t rsp_alignment, size_t needed_frame_size = 0) {
    auto frame_info = ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size);

-    for (std::size_t i = 0; i < regs.size(); ++i) {
+    for (size_t i = 0; i < regs.size(); ++i) {
        if (regs[i] && ABI_ALL_GPRS[i]) {
            code.push(IndexToReg64(i));
        }
@@ -192,7 +192,7 @@ inline size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::b
        code.sub(code.rsp, frame_info.subtraction);
    }

-    for (std::size_t i = 0; i < regs.size(); ++i) {
+    for (size_t i = 0; i < regs.size(); ++i) {
        if (regs[i] && ABI_ALL_XMMS[i]) {
            code.movaps(code.xword[code.rsp + frame_info.xmm_offset], IndexToXmm(i));
            frame_info.xmm_offset += 0x10;
@@ -206,7 +206,7 @@ inline void ABI_PopRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::bits
                                           size_t rsp_alignment, size_t needed_frame_size = 0) {
    auto frame_info = ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size);

-    for (std::size_t i = 0; i < regs.size(); ++i) {
+    for (size_t i = 0; i < regs.size(); ++i) {
        if (regs[i] && ABI_ALL_XMMS[i]) {
            code.movaps(IndexToXmm(i), code.xword[code.rsp + frame_info.xmm_offset]);
            frame_info.xmm_offset += 0x10;
@@ -218,8 +218,8 @@ inline void ABI_PopRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::bits
    }

    // GPRs need to be popped in reverse order
-    for (std::size_t j = 0; j < regs.size(); ++j) {
-        const std::size_t i = regs.size() - j - 1;
+    for (size_t j = 0; j < regs.size(); ++j) {
+        const size_t i = regs.size() - j - 1;
        if (regs[i] && ABI_ALL_GPRS[i]) {
            code.pop(IndexToReg64(i));
        }
@@ -12,17 +12,17 @@ namespace SystemVersionData {
 // This section should reflect the best system version to describe yuzu's HLE api.
 // TODO(DarkLordZach): Update when HLE gets better.

-constexpr u8 VERSION_MAJOR = 10;
+constexpr u8 VERSION_MAJOR = 11;
 constexpr u8 VERSION_MINOR = 0;
-constexpr u8 VERSION_MICRO = 2;
+constexpr u8 VERSION_MICRO = 0;

-constexpr u8 REVISION_MAJOR = 1;
+constexpr u8 REVISION_MAJOR = 5;
 constexpr u8 REVISION_MINOR = 0;

 constexpr char PLATFORM_STRING[] = "NX";
-constexpr char VERSION_HASH[] = "f90143fa8bbc061d4f68c35f95f04f8080c0ecdc";
-constexpr char DISPLAY_VERSION[] = "10.0.2";
-constexpr char DISPLAY_TITLE[] = "NintendoSDK Firmware for NX 10.0.2-1.0";
+constexpr char VERSION_HASH[] = "34197eba8810e2edd5e9dfcfbde7b340882e856d";
+constexpr char DISPLAY_VERSION[] = "11.0.0";
+constexpr char DISPLAY_TITLE[] = "NintendoSDK Firmware for NX 11.0.0-5.0";

 } // namespace SystemVersionData

@@ -57,8 +57,8 @@ public:
 private:
    void MergeAdjacent(iterator it, iterator& next_it);

-    const VAddr start_addr;
-    const VAddr end_addr;
+    [[maybe_unused]] const VAddr start_addr;
+    [[maybe_unused]] const VAddr end_addr;

    MemoryBlockTree memory_block_tree;
 };
@@ -45,7 +45,7 @@ public:
    }

 private:
-    FileSys::StorageId storage;
+    [[maybe_unused]] FileSys::StorageId storage;
 };

 class IRegisteredLocationResolver final : public ServiceFramework<IRegisteredLocationResolver> {
@@ -29,8 +29,8 @@
 #include "video_core/memory_manager.h"

 namespace Tegra {
-CDmaPusher::CDmaPusher(GPU& gpu)
-    : gpu(gpu), nvdec_processor(std::make_shared<Nvdec>(gpu)),
+CDmaPusher::CDmaPusher(GPU& gpu_)
+    : gpu{gpu_}, nvdec_processor(std::make_shared<Nvdec>(gpu)),
      vic_processor(std::make_unique<Vic>(gpu, nvdec_processor)),
      host1x_processor(std::make_unique<Host1x>(gpu)),
      nvdec_sync(std::make_unique<SyncptIncrManager>(gpu)),
@@ -100,11 +100,11 @@ void CDmaPusher::Step() {
    }
 }

-void CDmaPusher::ExecuteCommand(u32 offset, u32 data) {
+void CDmaPusher::ExecuteCommand(u32 state_offset, u32 data) {
    switch (current_class) {
    case ChClassId::NvDec:
-        ThiStateWrite(nvdec_thi_state, offset, {data});
-        switch (static_cast<ThiMethod>(offset)) {
+        ThiStateWrite(nvdec_thi_state, state_offset, {data});
+        switch (static_cast<ThiMethod>(state_offset)) {
        case ThiMethod::IncSyncpt: {
            LOG_DEBUG(Service_NVDRV, "NVDEC Class IncSyncpt Method");
            const auto syncpoint_id = static_cast<u32>(data & 0xFF);
@@ -120,16 +120,16 @@ void CDmaPusher::ExecuteCommand(u32 offset, u32 data) {
        case ThiMethod::SetMethod1:
            LOG_DEBUG(Service_NVDRV, "NVDEC method 0x{:X}",
                      static_cast<u32>(nvdec_thi_state.method_0));
-            nvdec_processor->ProcessMethod(
-                static_cast<Tegra::Nvdec::Method>(nvdec_thi_state.method_0), {data});
+            nvdec_processor->ProcessMethod(static_cast<Nvdec::Method>(nvdec_thi_state.method_0),
+                                           {data});
            break;
        default:
            break;
        }
        break;
    case ChClassId::GraphicsVic:
-        ThiStateWrite(vic_thi_state, static_cast<u32>(offset), {data});
-        switch (static_cast<ThiMethod>(offset)) {
+        ThiStateWrite(vic_thi_state, static_cast<u32>(state_offset), {data});
+        switch (static_cast<ThiMethod>(state_offset)) {
        case ThiMethod::IncSyncpt: {
            LOG_DEBUG(Service_NVDRV, "VIC Class IncSyncpt Method");
            const auto syncpoint_id = static_cast<u32>(data & 0xFF);
@@ -145,8 +145,7 @@ void CDmaPusher::ExecuteCommand(u32 offset, u32 data) {
        case ThiMethod::SetMethod1:
            LOG_DEBUG(Service_NVDRV, "VIC method 0x{:X}, Args=({})",
                      static_cast<u32>(vic_thi_state.method_0), data);
-            vic_processor->ProcessMethod(static_cast<Tegra::Vic::Method>(vic_thi_state.method_0),
-                                         {data});
+            vic_processor->ProcessMethod(static_cast<Vic::Method>(vic_thi_state.method_0), {data});
            break;
        default:
            break;
@@ -155,7 +154,7 @@ void CDmaPusher::ExecuteCommand(u32 offset, u32 data) {
    case ChClassId::Host1x:
        // This device is mainly for syncpoint synchronization
        LOG_DEBUG(Service_NVDRV, "Host1X Class Method");
-        host1x_processor->ProcessMethod(static_cast<Tegra::Host1x::Method>(offset), {data});
+        host1x_processor->ProcessMethod(static_cast<Host1x::Method>(state_offset), {data});
        break;
    default:
        UNIMPLEMENTED_MSG("Current class not implemented {:X}", static_cast<u32>(current_class));
@@ -163,9 +162,10 @@ void CDmaPusher::ExecuteCommand(u32 offset, u32 data) {
    }
 }

-void CDmaPusher::ThiStateWrite(ThiRegisters& state, u32 offset, const std::vector<u32>& arguments) {
-    u8* const state_offset = reinterpret_cast<u8*>(&state) + sizeof(u32) * offset;
-    std::memcpy(state_offset, arguments.data(), sizeof(u32) * arguments.size());
+void CDmaPusher::ThiStateWrite(ThiRegisters& state, u32 state_offset,
+                               const std::vector<u32>& arguments) {
+    u8* const state_offset_ptr = reinterpret_cast<u8*>(&state) + sizeof(u32) * state_offset;
+    std::memcpy(state_offset_ptr, arguments.data(), sizeof(u32) * arguments.size());
 }

 } // namespace Tegra
@@ -68,8 +68,8 @@ struct ChCommand {
    std::vector<u32> arguments;
 };

-using ChCommandHeaderList = std::vector<Tegra::ChCommandHeader>;
-using ChCommandList = std::vector<Tegra::ChCommand>;
+using ChCommandHeaderList = std::vector<ChCommandHeader>;
+using ChCommandList = std::vector<ChCommand>;

 struct ThiRegisters {
    u32_le increment_syncpt{};
@@ -96,7 +96,7 @@ enum class ThiMethod : u32 {

 class CDmaPusher {
 public:
-    explicit CDmaPusher(GPU& gpu);
+    explicit CDmaPusher(GPU& gpu_);
    ~CDmaPusher();

    /// Push NVDEC command buffer entries into queue
@@ -109,17 +109,17 @@ public:
    void Step();

    /// Invoke command class devices to execute the command based on the current state
-    void ExecuteCommand(u32 offset, u32 data);
+    void ExecuteCommand(u32 state_offset, u32 data);

 private:
    /// Write arguments value to the ThiRegisters member at the specified offset
-    void ThiStateWrite(ThiRegisters& state, u32 offset, const std::vector<u32>& arguments);
+    void ThiStateWrite(ThiRegisters& state, u32 state_offset, const std::vector<u32>& arguments);

    GPU& gpu;

-    std::shared_ptr<Tegra::Nvdec> nvdec_processor;
-    std::unique_ptr<Tegra::Vic> vic_processor;
-    std::unique_ptr<Tegra::Host1x> host1x_processor;
+    std::shared_ptr<Nvdec> nvdec_processor;
+    std::unique_ptr<Vic> vic_processor;
+    std::unique_ptr<Host1x> host1x_processor;
    std::unique_ptr<SyncptIncrManager> nvdec_sync;
    std::unique_ptr<SyncptIncrManager> vic_sync;
    ChClassId current_class{};
@@ -67,7 +67,6 @@ void Codec::Decode() {
        }

        av_codec_ctx = avcodec_alloc_context3(av_codec);
-        av_codec_ctx->refcounted_frames = 1;
        av_opt_set(av_codec_ctx->priv_data, "tune", "zerolatency", 0);

        // TODO(ameerj): libavcodec gpu hw acceleration
@@ -233,7 +233,7 @@ constexpr std::array<s32, 254> map_lut{
 }
 } // Anonymous namespace

-VP9::VP9(GPU& gpu) : gpu(gpu) {}
+VP9::VP9(GPU& gpu_) : gpu{gpu_} {}

 VP9::~VP9() = default;

@@ -355,7 +355,7 @@ void VP9::WriteMvProbabilityUpdate(VpxRangeEncoder& writer, u8 new_prob, u8 old_
 Vp9PictureInfo VP9::GetVp9PictureInfo(const NvdecCommon::NvdecRegisters& state) {
    PictureInfo picture_info{};
    gpu.MemoryManager().ReadBlock(state.picture_info_offset, &picture_info, sizeof(PictureInfo));
-    Vp9PictureInfo vp9_info = std::move(picture_info.Convert());
+    Vp9PictureInfo vp9_info = picture_info.Convert();

    InsertEntropy(state.vp9_entropy_probs_offset, vp9_info.entropy);

@@ -374,43 +374,43 @@ void VP9::InsertEntropy(u64 offset, Vp9EntropyProbs& dst) {
 }

 Vp9FrameContainer VP9::GetCurrentFrame(const NvdecCommon::NvdecRegisters& state) {
-    Vp9FrameContainer frame{};
+    Vp9FrameContainer current_frame{};
    {
        gpu.SyncGuestHost();
-        frame.info = std::move(GetVp9PictureInfo(state));
-        frame.bit_stream.resize(frame.info.bitstream_size);
-        gpu.MemoryManager().ReadBlock(state.frame_bitstream_offset, frame.bit_stream.data(),
-                                      frame.info.bitstream_size);
+        current_frame.info = GetVp9PictureInfo(state);
+        current_frame.bit_stream.resize(current_frame.info.bitstream_size);
+        gpu.MemoryManager().ReadBlock(state.frame_bitstream_offset, current_frame.bit_stream.data(),
+                                      current_frame.info.bitstream_size);
    }
    // Buffer two frames, saving the last show frame info
    if (!next_next_frame.bit_stream.empty()) {
        Vp9FrameContainer temp{
-            .info = std::move(frame.info),
-            .bit_stream = std::move(frame.bit_stream),
+            .info = current_frame.info,
+            .bit_stream = std::move(current_frame.bit_stream),
        };
-        next_next_frame.info.show_frame = frame.info.last_frame_shown;
-        frame.info = std::move(next_next_frame.info);
-        frame.bit_stream = std::move(next_next_frame.bit_stream);
+        next_next_frame.info.show_frame = current_frame.info.last_frame_shown;
+        current_frame.info = next_next_frame.info;
+        current_frame.bit_stream = std::move(next_next_frame.bit_stream);
        next_next_frame = std::move(temp);

        if (!next_frame.bit_stream.empty()) {
            Vp9FrameContainer temp2{
-                .info = std::move(frame.info),
-                .bit_stream = std::move(frame.bit_stream),
+                .info = current_frame.info,
+                .bit_stream = std::move(current_frame.bit_stream),
            };
-            next_frame.info.show_frame = frame.info.last_frame_shown;
-            frame.info = std::move(next_frame.info);
-            frame.bit_stream = std::move(next_frame.bit_stream);
+            next_frame.info.show_frame = current_frame.info.last_frame_shown;
+            current_frame.info = next_frame.info;
+            current_frame.bit_stream = std::move(next_frame.bit_stream);
            next_frame = std::move(temp2);
        } else {
-            next_frame.info = std::move(frame.info);
-            next_frame.bit_stream = std::move(frame.bit_stream);
+            next_frame.info = current_frame.info;
+            next_frame.bit_stream = std::move(current_frame.bit_stream);
        }
    } else {
-        next_next_frame.info = std::move(frame.info);
-        next_next_frame.bit_stream = std::move(frame.bit_stream);
+        next_next_frame.info = current_frame.info;
+        next_next_frame.bit_stream = std::move(current_frame.bit_stream);
    }
-    return frame;
+    return current_frame;
 }

 std::vector<u8> VP9::ComposeCompressedHeader() {
@@ -806,8 +806,8 @@ VpxBitStreamWriter VP9::ComposeUncompressedHeader() {
 const std::vector<u8>& VP9::ComposeFrameHeader(const NvdecCommon::NvdecRegisters& state) {
    std::vector<u8> bitstream;
    {
-        Vp9FrameContainer curr_frame = std::move(GetCurrentFrame(state));
-        current_frame_info = std::move(curr_frame.info);
+        Vp9FrameContainer curr_frame = GetCurrentFrame(state);
+        current_frame_info = curr_frame.info;
        bitstream = std::move(curr_frame.bit_stream);
    }

@@ -108,7 +108,7 @@ private:

 class VP9 {
 public:
-    explicit VP9(GPU& gpu);
+    explicit VP9(GPU& gpu_);
    ~VP9();

    VP9(const VP9&) = delete;
@@ -58,7 +58,7 @@ void Vic::Execute() {
        return;
    }
    const VicConfig config{gpu.MemoryManager().Read<u64>(config_struct_address + 0x20)};
-    const AVFramePtr frame_ptr = std::move(nvdec_processor->GetFrame());
+    const AVFramePtr frame_ptr = nvdec_processor->GetFrame();
    const auto* frame = frame_ptr.get();
    if (!frame || frame->width == 0 || frame->height == 0) {
        return;
@@ -13,7 +13,7 @@

 namespace Tegra {

-DmaPusher::DmaPusher(Core::System& system, GPU& gpu) : gpu{gpu}, system{system} {}
+DmaPusher::DmaPusher(Core::System& system_, GPU& gpu_) : gpu{gpu_}, system{system_} {}

 DmaPusher::~DmaPusher() = default;

@@ -152,7 +152,12 @@ void DmaPusher::SetState(const CommandHeader& command_header) {

 void DmaPusher::CallMethod(u32 argument) const {
    if (dma_state.method < non_puller_methods) {
-        gpu.CallMethod({dma_state.method, argument, dma_state.subchannel, dma_state.method_count});
+        gpu.CallMethod(GPU::MethodCall{
+            dma_state.method,
+            argument,
+            dma_state.subchannel,
+            dma_state.method_count,
+        });
    } else {
        subchannels[dma_state.subchannel]->CallMethod(dma_state.method, argument,
                                                      dma_state.is_last_call);
@@ -87,11 +87,11 @@ inline CommandHeader BuildCommandHeader(BufferMethods method, u32 arg_count, Sub
 struct CommandList final {
    CommandList() = default;
    explicit CommandList(std::size_t size) : command_lists(size) {}
-    explicit CommandList(std::vector<Tegra::CommandHeader>&& prefetch_command_list)
-        : prefetch_command_list{std::move(prefetch_command_list)} {}
+    explicit CommandList(std::vector<CommandHeader>&& prefetch_command_list_)
+        : prefetch_command_list{std::move(prefetch_command_list_)} {}

-    std::vector<Tegra::CommandListHeader> command_lists;
-    std::vector<Tegra::CommandHeader> prefetch_command_list;
+    std::vector<CommandListHeader> command_lists;
+    std::vector<CommandHeader> prefetch_command_list;
 };

 /**
@@ -103,7 +103,7 @@ struct CommandList final {
 */
 class DmaPusher final {
 public:
-    explicit DmaPusher(Core::System& system, GPU& gpu);
+    explicit DmaPusher(Core::System& system_, GPU& gpu_);
    ~DmaPusher();

    void Push(CommandList&& entries) {
@@ -112,7 +112,7 @@ public:

    void DispatchCalls();

-    void BindSubchannel(Tegra::Engines::EngineInterface* engine, u32 subchannel_id) {
+    void BindSubchannel(Engines::EngineInterface* engine, u32 subchannel_id) {
        subchannels[subchannel_id] = engine;
    }

@@ -145,7 +145,7 @@ private:

    bool ib_enable{true}; ///< IB mode enabled

-    std::array<Tegra::Engines::EngineInterface*, max_subchannels> subchannels{};
+    std::array<Engines::EngineInterface*, max_subchannels> subchannels{};

    GPU& gpu;
    Core::System& system;
@@ -11,16 +11,16 @@

 namespace Tegra::Engines::Upload {

-State::State(MemoryManager& memory_manager, Registers& regs)
-    : regs{regs}, memory_manager{memory_manager} {}
+State::State(MemoryManager& memory_manager_, Registers& regs_)
+    : regs{regs_}, memory_manager{memory_manager_} {}

 State::~State() = default;

-void State::ProcessExec(const bool is_linear) {
+void State::ProcessExec(const bool is_linear_) {
    write_offset = 0;
    copy_size = regs.line_length_in * regs.line_count;
    inner_buffer.resize(copy_size);
-    this->is_linear = is_linear;
+    is_linear = is_linear_;
 }

 void State::ProcessData(const u32 data, const bool is_last_call) {
@@ -54,10 +54,10 @@ struct Registers {

 class State {
 public:
-    State(MemoryManager& memory_manager, Registers& regs);
+    explicit State(MemoryManager& memory_manager_, Registers& regs_);
    ~State();

-    void ProcessExec(bool is_linear);
+    void ProcessExec(bool is_linear_);
    void ProcessData(u32 data, bool is_last_call);

 private:
@@ -14,8 +14,8 @@

 namespace Tegra::Engines {

-KeplerMemory::KeplerMemory(Core::System& system, MemoryManager& memory_manager)
-    : system{system}, upload_state{memory_manager, regs.upload} {}
+KeplerMemory::KeplerMemory(Core::System& system_, MemoryManager& memory_manager)
+    : system{system_}, upload_state{memory_manager, regs.upload} {}

 KeplerMemory::~KeplerMemory() = default;

@@ -35,7 +35,7 @@ namespace Tegra::Engines {

 class KeplerMemory final : public EngineInterface {
 public:
-    KeplerMemory(Core::System& system, MemoryManager& memory_manager);
+    explicit KeplerMemory(Core::System& system_, MemoryManager& memory_manager);
    ~KeplerMemory();

    /// Write the value to the register identified by method.
@@ -16,8 +16,10 @@ namespace Tegra::Engines {

 using namespace Texture;

-MaxwellDMA::MaxwellDMA(Core::System& system, MemoryManager& memory_manager)
-    : system{system}, memory_manager{memory_manager} {}
+MaxwellDMA::MaxwellDMA(Core::System& system_, MemoryManager& memory_manager_)
+    : system{system_}, memory_manager{memory_manager_} {}
+
+MaxwellDMA::~MaxwellDMA() = default;

 void MaxwellDMA::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
    ASSERT_MSG(method < NUM_REGS, "Invalid MaxwellDMA register");
@@ -72,11 +72,13 @@ public:

    struct RenderEnable {
        enum class Mode : u32 {
-            FALSE = 0,
-            TRUE = 1,
-            CONDITIONAL = 2,
-            RENDER_IF_EQUAL = 3,
-            RENDER_IF_NOT_EQUAL = 4,
+            // Note: This uses Pascal case in order to avoid the identifiers
+            // FALSE and TRUE, which are reserved on Darwin.
+            False = 0,
+            True = 1,
+            Conditional = 2,
+            RenderIfEqual = 3,
+            RenderIfNotEqual = 4,
        };

        PackedGPUVAddr address;
@@ -185,8 +187,8 @@ public:
    };
    static_assert(sizeof(RemapConst) == 12);

-    explicit MaxwellDMA(Core::System& system, MemoryManager& memory_manager);
-    ~MaxwellDMA() = default;
+    explicit MaxwellDMA(Core::System& system_, MemoryManager& memory_manager_);
+    ~MaxwellDMA();

    /// Write the value to the register identified by method.
    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
@@ -17,11 +17,11 @@ namespace VideoCommon {

 class FenceBase {
 public:
-    FenceBase(u32 payload, bool is_stubbed)
-        : address{}, payload{payload}, is_semaphore{false}, is_stubbed{is_stubbed} {}
+    explicit FenceBase(u32 payload_, bool is_stubbed_)
+        : address{}, payload{payload_}, is_semaphore{false}, is_stubbed{is_stubbed_} {}

-    FenceBase(GPUVAddr address, u32 payload, bool is_stubbed)
-        : address{address}, payload{payload}, is_semaphore{true}, is_stubbed{is_stubbed} {}
+    explicit FenceBase(GPUVAddr address_, u32 payload_, bool is_stubbed_)
+        : address{address_}, payload{payload_}, is_semaphore{true}, is_stubbed{is_stubbed_} {}

    GPUVAddr GetAddress() const {
        return address;
@@ -232,8 +232,12 @@ void GPU::CallMultiMethod(u32 method, u32 subchannel, const u32* base_start, u32
        CallEngineMultiMethod(method, subchannel, base_start, amount, methods_pending);
    } else {
        for (std::size_t i = 0; i < amount; i++) {
-            CallPullerMethod(
-                {method, base_start[i], subchannel, methods_pending - static_cast<u32>(i)});
+            CallPullerMethod(MethodCall{
+                method,
+                base_start[i],
+                subchannel,
+                methods_pending - static_cast<u32>(i),
+            });
        }
    }
 }
@@ -149,16 +149,16 @@ public:
        u32 subchannel{};
        u32 method_count{};

-        MethodCall(u32 method, u32 argument, u32 subchannel = 0, u32 method_count = 0)
-            : method(method), argument(argument), subchannel(subchannel),
-              method_count(method_count) {}
+        explicit MethodCall(u32 method_, u32 argument_, u32 subchannel_ = 0, u32 method_count_ = 0)
+            : method(method_), argument(argument_), subchannel(subchannel_),
+              method_count(method_count_) {}

        [[nodiscard]] bool IsLastCall() const {
            return method_count <= 1;
        }
    };

-    explicit GPU(Core::System& system, bool is_async, bool use_nvdec);
+    explicit GPU(Core::System& system_, bool is_async_, bool use_nvdec_);
    virtual ~GPU();

    /// Binds a renderer to the GPU.
@@ -414,8 +414,8 @@ private:
    std::condition_variable sync_cv;

    struct FlushRequest {
-        FlushRequest(u64 fence, VAddr addr, std::size_t size)
-            : fence{fence}, addr{addr}, size{size} {}
+        explicit FlushRequest(u64 fence_, VAddr addr_, std::size_t size_)
+            : fence{fence_}, addr{addr_}, size{size_} {}
        u64 fence;
        VAddr addr;
        std::size_t size;
@@ -10,8 +10,8 @@

 namespace VideoCommon {

-GPUAsynch::GPUAsynch(Core::System& system, bool use_nvdec)
-    : GPU{system, true, use_nvdec}, gpu_thread{system} {}
+GPUAsynch::GPUAsynch(Core::System& system_, bool use_nvdec_)
+    : GPU{system_, true, use_nvdec_}, gpu_thread{system_} {}

 GPUAsynch::~GPUAsynch() = default;

@@ -20,7 +20,7 @@ namespace VideoCommon {
 /// Implementation of GPU interface that runs the GPU asynchronously
 class GPUAsynch final : public Tegra::GPU {
 public:
-    explicit GPUAsynch(Core::System& system, bool use_nvdec);
+    explicit GPUAsynch(Core::System& system_, bool use_nvdec_);
    ~GPUAsynch() override;

    void Start() override;
@@ -7,7 +7,7 @@

 namespace VideoCommon {

-GPUSynch::GPUSynch(Core::System& system, bool use_nvdec) : GPU{system, false, use_nvdec} {}
+GPUSynch::GPUSynch(Core::System& system_, bool use_nvdec_) : GPU{system_, false, use_nvdec_} {}

 GPUSynch::~GPUSynch() = default;

@@ -19,7 +19,7 @@ namespace VideoCommon {
 /// Implementation of GPU interface that runs the GPU synchronously
 class GPUSynch final : public Tegra::GPU {
 public:
-    explicit GPUSynch(Core::System& system, bool use_nvdec);
+    explicit GPUSynch(Core::System& system_, bool use_nvdec_);
    ~GPUSynch() override;

    void Start() override;
@@ -39,23 +39,23 @@ static void RunThread(Core::System& system, VideoCore::RendererBase& renderer,
    CommandDataContainer next;
    while (state.is_running) {
        next = state.queue.PopWait();
-        if (const auto submit_list = std::get_if<SubmitListCommand>(&next.data)) {
+        if (auto* submit_list = std::get_if<SubmitListCommand>(&next.data)) {
            dma_pusher.Push(std::move(submit_list->entries));
            dma_pusher.DispatchCalls();
-        } else if (const auto command_list = std::get_if<SubmitChCommandEntries>(&next.data)) {
+        } else if (auto* command_list = std::get_if<SubmitChCommandEntries>(&next.data)) {
            // NVDEC
            cdma_pusher.Push(std::move(command_list->entries));
            cdma_pusher.DispatchCalls();
-        } else if (const auto data = std::get_if<SwapBuffersCommand>(&next.data)) {
+        } else if (const auto* data = std::get_if<SwapBuffersCommand>(&next.data)) {
            renderer.SwapBuffers(data->framebuffer ? &*data->framebuffer : nullptr);
        } else if (std::holds_alternative<OnCommandListEndCommand>(next.data)) {
            renderer.Rasterizer().ReleaseFences();
        } else if (std::holds_alternative<GPUTickCommand>(next.data)) {
            system.GPU().TickWork();
-        } else if (const auto data = std::get_if<FlushRegionCommand>(&next.data)) {
-            renderer.Rasterizer().FlushRegion(data->addr, data->size);
-        } else if (const auto data = std::get_if<InvalidateRegionCommand>(&next.data)) {
-            renderer.Rasterizer().OnCPUWrite(data->addr, data->size);
+        } else if (const auto* flush = std::get_if<FlushRegionCommand>(&next.data)) {
+            renderer.Rasterizer().FlushRegion(flush->addr, flush->size);
+        } else if (const auto* invalidate = std::get_if<InvalidateRegionCommand>(&next.data)) {
+            renderer.Rasterizer().OnCPUWrite(invalidate->addr, invalidate->size);
        } else if (std::holds_alternative<EndProcessingCommand>(next.data)) {
            return;
        } else {
@@ -65,7 +65,7 @@ static void RunThread(Core::System& system, VideoCore::RendererBase& renderer,
    }
 }

-ThreadManager::ThreadManager(Core::System& system) : system{system} {}
+ThreadManager::ThreadManager(Core::System& system_) : system{system_} {}

 ThreadManager::~ThreadManager() {
    if (!thread.joinable()) {
@@ -32,30 +32,30 @@ struct EndProcessingCommand final {};

 /// Command to signal to the GPU thread that a command list is ready for processing
 struct SubmitListCommand final {
-    explicit SubmitListCommand(Tegra::CommandList&& entries) : entries{std::move(entries)} {}
+    explicit SubmitListCommand(Tegra::CommandList&& entries_) : entries{std::move(entries_)} {}

    Tegra::CommandList entries;
 };

 /// Command to signal to the GPU thread that a cdma command list is ready for processing
 struct SubmitChCommandEntries final {
-    explicit SubmitChCommandEntries(Tegra::ChCommandHeaderList&& entries)
-        : entries{std::move(entries)} {}
+    explicit SubmitChCommandEntries(Tegra::ChCommandHeaderList&& entries_)
+        : entries{std::move(entries_)} {}

    Tegra::ChCommandHeaderList entries;
 };

 /// Command to signal to the GPU thread that a swap buffers is pending
 struct SwapBuffersCommand final {
-    explicit SwapBuffersCommand(std::optional<const Tegra::FramebufferConfig> framebuffer)
-        : framebuffer{std::move(framebuffer)} {}
+    explicit SwapBuffersCommand(std::optional<const Tegra::FramebufferConfig> framebuffer_)
+        : framebuffer{std::move(framebuffer_)} {}

    std::optional<Tegra::FramebufferConfig> framebuffer;
 };

 /// Command to signal to the GPU thread to flush a region
 struct FlushRegionCommand final {
-    explicit constexpr FlushRegionCommand(VAddr addr, u64 size) : addr{addr}, size{size} {}
+    explicit constexpr FlushRegionCommand(VAddr addr_, u64 size_) : addr{addr_}, size{size_} {}

    VAddr addr;
    u64 size;
@@ -63,7 +63,7 @@ struct FlushRegionCommand final {

 /// Command to signal to the GPU thread to invalidate a region
 struct InvalidateRegionCommand final {
-    explicit constexpr InvalidateRegionCommand(VAddr addr, u64 size) : addr{addr}, size{size} {}
+    explicit constexpr InvalidateRegionCommand(VAddr addr_, u64 size_) : addr{addr_}, size{size_} {}

    VAddr addr;
    u64 size;
@@ -71,8 +71,8 @@ struct InvalidateRegionCommand final {

 /// Command to signal to the GPU thread to flush and invalidate a region
 struct FlushAndInvalidateRegionCommand final {
-    explicit constexpr FlushAndInvalidateRegionCommand(VAddr addr, u64 size)
-        : addr{addr}, size{size} {}
+    explicit constexpr FlushAndInvalidateRegionCommand(VAddr addr_, u64 size_)
+        : addr{addr_}, size{size_} {}

    VAddr addr;
    u64 size;
@@ -92,8 +92,8 @@ using CommandData =
 struct CommandDataContainer {
    CommandDataContainer() = default;

-    CommandDataContainer(CommandData&& data, u64 next_fence)
-        : data{std::move(data)}, fence{next_fence} {}
+    explicit CommandDataContainer(CommandData&& data_, u64 next_fence_)
+        : data{std::move(data_)}, fence{next_fence_} {}

    CommandData data;
    u64 fence{};
@@ -112,7 +112,7 @@ struct SynchState final {
 /// Class used to manage the GPU thread
 class ThreadManager final {
 public:
-    explicit ThreadManager(Core::System& system);
+    explicit ThreadManager(Core::System& system_);
    ~ThreadManager();

    /// Creates and starts the GPU thread.
@@ -146,7 +146,6 @@ private:
    /// Pushes a command to be executed by the GPU thread
    u64 PushCommand(CommandData&& command_data);

-private:
    SynchState state;
    Core::System& system;
    std::thread thread;
@@ -19,8 +19,8 @@ namespace VideoCore {
 class GuestDriverProfile {
 public:
    explicit GuestDriverProfile() = default;
-    explicit GuestDriverProfile(std::optional<u32> texture_handler_size)
-        : texture_handler_size{texture_handler_size} {}
+    explicit GuestDriverProfile(std::optional<u32> texture_handler_size_)
+        : texture_handler_size{texture_handler_size_} {}

    void DeduceTextureHandlerSize(std::vector<u32> bound_offsets);

@@ -85,7 +85,7 @@ constexpr std::array<std::pair<u64, HLEFunction>, 3> hle_funcs{{
    {0x0217920100488FF7, &HLE_0217920100488FF7},
 }};

-HLEMacro::HLEMacro(Engines::Maxwell3D& maxwell3d) : maxwell3d(maxwell3d) {}
+HLEMacro::HLEMacro(Engines::Maxwell3D& maxwell3d_) : maxwell3d{maxwell3d_} {}
 HLEMacro::~HLEMacro() = default;

 std::optional<std::unique_ptr<CachedMacro>> HLEMacro::GetHLEProgram(u64 hash) const {
@@ -99,8 +99,8 @@ std::optional<std::unique_ptr<CachedMacro>> HLEMacro::GetHLEProgram(u64 hash) co

 HLEMacroImpl::~HLEMacroImpl() = default;

-HLEMacroImpl::HLEMacroImpl(Engines::Maxwell3D& maxwell3d, HLEFunction func)
-    : maxwell3d(maxwell3d), func(func) {}
+HLEMacroImpl::HLEMacroImpl(Engines::Maxwell3D& maxwell3d_, HLEFunction func_)
+    : maxwell3d{maxwell3d_}, func{func_} {}

 void HLEMacroImpl::Execute(const std::vector<u32>& parameters, u32 method) {
    func(maxwell3d, parameters);
@@ -20,7 +20,7 @@ using HLEFunction = void (*)(Engines::Maxwell3D& maxwell3d, const std::vector<u3

 class HLEMacro {
 public:
-    explicit HLEMacro(Engines::Maxwell3D& maxwell3d);
+    explicit HLEMacro(Engines::Maxwell3D& maxwell3d_);
    ~HLEMacro();

    std::optional<std::unique_ptr<CachedMacro>> GetHLEProgram(u64 hash) const;
@@ -11,29 +11,29 @@
 MICROPROFILE_DEFINE(MacroInterp, "GPU", "Execute macro interpreter", MP_RGB(128, 128, 192));

 namespace Tegra {
-MacroInterpreter::MacroInterpreter(Engines::Maxwell3D& maxwell3d)
-    : MacroEngine::MacroEngine(maxwell3d), maxwell3d(maxwell3d) {}
+MacroInterpreter::MacroInterpreter(Engines::Maxwell3D& maxwell3d_)
+    : MacroEngine{maxwell3d_}, maxwell3d{maxwell3d_} {}

 std::unique_ptr<CachedMacro> MacroInterpreter::Compile(const std::vector<u32>& code) {
    return std::make_unique<MacroInterpreterImpl>(maxwell3d, code);
 }

-MacroInterpreterImpl::MacroInterpreterImpl(Engines::Maxwell3D& maxwell3d,
-                                           const std::vector<u32>& code)
-    : maxwell3d(maxwell3d), code(code) {}
+MacroInterpreterImpl::MacroInterpreterImpl(Engines::Maxwell3D& maxwell3d_,
+                                           const std::vector<u32>& code_)
+    : maxwell3d{maxwell3d_}, code{code_} {}

-void MacroInterpreterImpl::Execute(const std::vector<u32>& parameters, u32 method) {
+void MacroInterpreterImpl::Execute(const std::vector<u32>& params, u32 method) {
    MICROPROFILE_SCOPE(MacroInterp);
    Reset();

-    registers[1] = parameters[0];
-    num_parameters = parameters.size();
+    registers[1] = params[0];
+    num_parameters = params.size();

    if (num_parameters > parameters_capacity) {
        parameters_capacity = num_parameters;
-        this->parameters = std::make_unique<u32[]>(num_parameters);
+        parameters = std::make_unique<u32[]>(num_parameters);
    }
-    std::memcpy(this->parameters.get(), parameters.data(), num_parameters * sizeof(u32));
+    std::memcpy(parameters.get(), params.data(), num_parameters * sizeof(u32));

    // Execute the code until we hit an exit condition.
    bool keep_executing = true;
@@ -17,7 +17,7 @@ class Maxwell3D;

 class MacroInterpreter final : public MacroEngine {
 public:
-    explicit MacroInterpreter(Engines::Maxwell3D& maxwell3d);
+    explicit MacroInterpreter(Engines::Maxwell3D& maxwell3d_);

 protected:
    std::unique_ptr<CachedMacro> Compile(const std::vector<u32>& code) override;
@@ -28,8 +28,8 @@ private:

 class MacroInterpreterImpl : public CachedMacro {
 public:
-    MacroInterpreterImpl(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& code);
-    void Execute(const std::vector<u32>& parameters, u32 method) override;
+    explicit MacroInterpreterImpl(Engines::Maxwell3D& maxwell3d_, const std::vector<u32>& code_);
+    void Execute(const std::vector<u32>& params, u32 method) override;

 private:
    /// Resets the execution engine state, zeroing registers, etc.
@@ -38,9 +38,9 @@ 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 is_delay_slot Whether the current step is being executed due to a delay slot in a
-     * previous instruction.
+     *                      previous instruction.
     */
    bool Step(bool is_delay_slot);

@@ -28,15 +28,15 @@ static const std::bitset<32> PERSISTENT_REGISTERS = Common::X64::BuildRegSet({
    BRANCH_HOLDER,
 });

-MacroJITx64::MacroJITx64(Engines::Maxwell3D& maxwell3d)
-    : MacroEngine::MacroEngine(maxwell3d), maxwell3d(maxwell3d) {}
+MacroJITx64::MacroJITx64(Engines::Maxwell3D& maxwell3d_)
+    : MacroEngine{maxwell3d_}, maxwell3d{maxwell3d_} {}

 std::unique_ptr<CachedMacro> MacroJITx64::Compile(const std::vector<u32>& code) {
    return std::make_unique<MacroJITx64Impl>(maxwell3d, code);
 }

-MacroJITx64Impl::MacroJITx64Impl(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& code)
-    : Xbyak::CodeGenerator(MAX_CODE_SIZE), code(code), maxwell3d(maxwell3d) {
+MacroJITx64Impl::MacroJITx64Impl(Engines::Maxwell3D& maxwell3d_, const std::vector<u32>& code_)
+    : CodeGenerator{MAX_CODE_SIZE}, code{code_}, maxwell3d{maxwell3d_} {
    Compile();
 }

@@ -553,15 +553,15 @@ Xbyak::Reg32 MacroJITx64Impl::Compile_GetRegister(u32 index, Xbyak::Reg32 dst) {
 }

 void MacroJITx64Impl::Compile_ProcessResult(Macro::ResultOperation operation, u32 reg) {
-    const auto SetRegister = [this](u32 reg, const Xbyak::Reg32& result) {
+    const auto SetRegister = [this](u32 reg_index, const Xbyak::Reg32& result) {
        // Register 0 is supposed to always return 0. NOP is implemented as a store to the zero
        // register.
-        if (reg == 0) {
+        if (reg_index == 0) {
            return;
        }
-        mov(dword[STATE + offsetof(JITState, registers) + reg * sizeof(u32)], result);
+        mov(dword[STATE + offsetof(JITState, registers) + reg_index * sizeof(u32)], result);
    };
-    const auto SetMethodAddress = [this](const Xbyak::Reg32& reg) { mov(METHOD_ADDRESS, reg); };
+    const auto SetMethodAddress = [this](const Xbyak::Reg32& reg32) { mov(METHOD_ADDRESS, reg32); };

    switch (operation) {
    case Macro::ResultOperation::IgnoreAndFetch:
@@ -23,7 +23,7 @@ constexpr size_t MAX_CODE_SIZE = 0x10000;

 class MacroJITx64 final : public MacroEngine {
 public:
-    explicit MacroJITx64(Engines::Maxwell3D& maxwell3d);
+    explicit MacroJITx64(Engines::Maxwell3D& maxwell3d_);

 protected:
    std::unique_ptr<CachedMacro> Compile(const std::vector<u32>& code) override;
@@ -34,7 +34,7 @@ private:

 class MacroJITx64Impl : public Xbyak::CodeGenerator, public CachedMacro {
 public:
-    MacroJITx64Impl(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& code);
+    explicit MacroJITx64Impl(Engines::Maxwell3D& maxwell3d_, const std::vector<u32>& code_);
    ~MacroJITx64Impl();

    void Execute(const std::vector<u32>& parameters, u32 method) override;
@@ -28,7 +28,7 @@ public:
    };

    constexpr PageEntry() = default;
-    constexpr PageEntry(State state) : state{state} {}
+    constexpr PageEntry(State state_) : state{state_} {}
    constexpr PageEntry(VAddr addr) : state{static_cast<State>(addr >> ShiftBits)} {}

    [[nodiscard]] constexpr bool IsUnmapped() const {
@@ -68,7 +68,7 @@ static_assert(sizeof(PageEntry) == 4, "PageEntry is too large");

 class MemoryManager final {
 public:
-    explicit MemoryManager(Core::System& system);
+    explicit MemoryManager(Core::System& system_);
    ~MemoryManager();

    /// Binds a renderer to the memory manager.
@@ -187,8 +187,8 @@ std::string TextureType(const MetaTexture& meta) {

 class ARBDecompiler final {
 public:
-    explicit ARBDecompiler(const Device& device, const ShaderIR& ir, const Registry& registry,
-                           ShaderType stage, std::string_view identifier);
+    explicit ARBDecompiler(const Device& device_, const ShaderIR& ir_, const Registry& registry_,
+                           ShaderType stage_, std::string_view identifier);

    std::string Code() const {
        return shader_source;
@@ -802,9 +802,9 @@ private:
    };
 };

-ARBDecompiler::ARBDecompiler(const Device& device, const ShaderIR& ir, const Registry& registry,
-                             ShaderType stage, std::string_view identifier)
-    : device{device}, ir{ir}, registry{registry}, stage{stage} {
+ARBDecompiler::ARBDecompiler(const Device& device_, const ShaderIR& ir_, const Registry& registry_,
+                             ShaderType stage_, std::string_view identifier)
+    : device{device_}, ir{ir_}, registry{registry_}, stage{stage_} {
    DefineGlobalMemory();

    AddLine("TEMP RC;");
@@ -1134,44 +1134,44 @@ void ARBDecompiler::VisitAST(const ASTNode& node) {
        for (ASTNode current = ast->nodes.GetFirst(); current; current = current->GetNext()) {
            VisitAST(current);
        }
-    } else if (const auto ast = std::get_if<ASTIfThen>(&*node->GetInnerData())) {
-        const std::string condition = VisitExpression(ast->condition);
+    } else if (const auto if_then = std::get_if<ASTIfThen>(&*node->GetInnerData())) {
+        const std::string condition = VisitExpression(if_then->condition);
        ResetTemporaries();

        AddLine("MOVC.U RC.x, {};", condition);
        AddLine("IF NE.x;");
-        for (ASTNode current = ast->nodes.GetFirst(); current; current = current->GetNext()) {
+        for (ASTNode current = if_then->nodes.GetFirst(); current; current = current->GetNext()) {
            VisitAST(current);
        }
        AddLine("ENDIF;");
-    } else if (const auto ast = std::get_if<ASTIfElse>(&*node->GetInnerData())) {
+    } else if (const auto if_else = std::get_if<ASTIfElse>(&*node->GetInnerData())) {
        AddLine("ELSE;");
-        for (ASTNode current = ast->nodes.GetFirst(); current; current = current->GetNext()) {
+        for (ASTNode current = if_else->nodes.GetFirst(); current; current = current->GetNext()) {
            VisitAST(current);
        }
-    } else if (const auto ast = std::get_if<ASTBlockDecoded>(&*node->GetInnerData())) {
-        VisitBlock(ast->nodes);
-    } else if (const auto ast = std::get_if<ASTVarSet>(&*node->GetInnerData())) {
-        AddLine("MOV.U F{}, {};", ast->index, VisitExpression(ast->condition));
+    } else if (const auto decoded = std::get_if<ASTBlockDecoded>(&*node->GetInnerData())) {
+        VisitBlock(decoded->nodes);
+    } else if (const auto var_set = std::get_if<ASTVarSet>(&*node->GetInnerData())) {
+        AddLine("MOV.U F{}, {};", var_set->index, VisitExpression(var_set->condition));
        ResetTemporaries();
-    } else if (const auto ast = std::get_if<ASTDoWhile>(&*node->GetInnerData())) {
-        const std::string condition = VisitExpression(ast->condition);
+    } else if (const auto do_while = std::get_if<ASTDoWhile>(&*node->GetInnerData())) {
+        const std::string condition = VisitExpression(do_while->condition);
        ResetTemporaries();
        AddLine("REP;");
-        for (ASTNode current = ast->nodes.GetFirst(); current; current = current->GetNext()) {
+        for (ASTNode current = do_while->nodes.GetFirst(); current; current = current->GetNext()) {
            VisitAST(current);
        }
        AddLine("MOVC.U RC.x, {};", condition);
        AddLine("BRK (NE.x);");
        AddLine("ENDREP;");
-    } else if (const auto ast = std::get_if<ASTReturn>(&*node->GetInnerData())) {
-        const bool is_true = ExprIsTrue(ast->condition);
+    } else if (const auto ast_return = std::get_if<ASTReturn>(&*node->GetInnerData())) {
+        const bool is_true = ExprIsTrue(ast_return->condition);
        if (!is_true) {
-            AddLine("MOVC.U RC.x, {};", VisitExpression(ast->condition));
+            AddLine("MOVC.U RC.x, {};", VisitExpression(ast_return->condition));
            AddLine("IF NE.x;");
            ResetTemporaries();
        }
-        if (ast->kills) {
+        if (ast_return->kills) {
            AddLine("KIL TR;");
        } else {
            Exit();
@@ -1179,11 +1179,11 @@ void ARBDecompiler::VisitAST(const ASTNode& node) {
        if (!is_true) {
            AddLine("ENDIF;");
        }
-    } else if (const auto ast = std::get_if<ASTBreak>(&*node->GetInnerData())) {
-        if (ExprIsTrue(ast->condition)) {
+    } else if (const auto ast_break = std::get_if<ASTBreak>(&*node->GetInnerData())) {
+        if (ExprIsTrue(ast_break->condition)) {
            AddLine("BRK;");
        } else {
-            AddLine("MOVC.U RC.x, {};", VisitExpression(ast->condition));
+            AddLine("MOVC.U RC.x, {};", VisitExpression(ast_break->condition));
            AddLine("BRK (NE.x);");
            ResetTemporaries();
        }
@@ -11,10 +11,10 @@

 namespace OpenGL {

-GLInnerFence::GLInnerFence(u32 payload, bool is_stubbed) : FenceBase(payload, is_stubbed) {}
+GLInnerFence::GLInnerFence(u32 payload_, bool is_stubbed_) : FenceBase{payload_, is_stubbed_} {}

-GLInnerFence::GLInnerFence(GPUVAddr address, u32 payload, bool is_stubbed)
-    : FenceBase(address, payload, is_stubbed) {}
+GLInnerFence::GLInnerFence(GPUVAddr address_, u32 payload_, bool is_stubbed_)
+    : FenceBase{address_, payload_, is_stubbed_} {}

 GLInnerFence::~GLInnerFence() = default;

@@ -45,10 +45,10 @@ void GLInnerFence::Wait() {
    glClientWaitSync(sync_object.handle, 0, GL_TIMEOUT_IGNORED);
 }

-FenceManagerOpenGL::FenceManagerOpenGL(VideoCore::RasterizerInterface& rasterizer, Tegra::GPU& gpu,
-                                       TextureCacheOpenGL& texture_cache,
-                                       OGLBufferCache& buffer_cache, QueryCache& query_cache)
-    : GenericFenceManager{rasterizer, gpu, texture_cache, buffer_cache, query_cache} {}
+FenceManagerOpenGL::FenceManagerOpenGL(VideoCore::RasterizerInterface& rasterizer_,
+                                       Tegra::GPU& gpu_, TextureCacheOpenGL& texture_cache_,
+                                       OGLBufferCache& buffer_cache_, QueryCache& query_cache_)
+    : GenericFenceManager{rasterizer_, gpu_, texture_cache_, buffer_cache_, query_cache_} {}

 Fence FenceManagerOpenGL::CreateFence(u32 value, bool is_stubbed) {
    return std::make_shared<GLInnerFence>(value, is_stubbed);
@@ -17,8 +17,8 @@ namespace OpenGL {

 class GLInnerFence : public VideoCommon::FenceBase {
 public:
-    GLInnerFence(u32 payload, bool is_stubbed);
-    GLInnerFence(GPUVAddr address, u32 payload, bool is_stubbed);
+    explicit GLInnerFence(u32 payload_, bool is_stubbed_);
+    explicit GLInnerFence(GPUVAddr address_, u32 payload_, bool is_stubbed_);
    ~GLInnerFence();

    void Queue();
@@ -37,9 +37,9 @@ using GenericFenceManager =

 class FenceManagerOpenGL final : public GenericFenceManager {
 public:
-    explicit FenceManagerOpenGL(VideoCore::RasterizerInterface& rasterizer, Tegra::GPU& gpu,
-                                TextureCacheOpenGL& texture_cache, OGLBufferCache& buffer_cache,
-                                QueryCache& query_cache);
+    explicit FenceManagerOpenGL(VideoCore::RasterizerInterface& rasterizer_, Tegra::GPU& gpu_,
+                                TextureCacheOpenGL& texture_cache_, OGLBufferCache& buffer_cache_,
+                                QueryCache& query_cache_);

 protected:
    Fence CreateFence(u32 value, bool is_stubbed) override;
@@ -59,10 +59,10 @@ bool QueryCache::AnyCommandQueued() const noexcept {
    return gl_rasterizer.AnyCommandQueued();
 }

-HostCounter::HostCounter(QueryCache& cache, std::shared_ptr<HostCounter> dependency,
-                         VideoCore::QueryType type)
-    : VideoCommon::HostCounterBase<QueryCache, HostCounter>{std::move(dependency)}, cache{cache},
-      type{type}, query{cache.AllocateQuery(type)} {
+HostCounter::HostCounter(QueryCache& cache_, std::shared_ptr<HostCounter> dependency,
+                         VideoCore::QueryType type_)
+    : HostCounterBase<QueryCache, HostCounter>{std::move(dependency)}, cache{cache_}, type{type_},
+      query{cache.AllocateQuery(type)} {
    glBeginQuery(GetTarget(type), query.handle);
 }

@@ -86,13 +86,14 @@ u64 HostCounter::BlockingQuery() const {
    return static_cast<u64>(value);
 }

-CachedQuery::CachedQuery(QueryCache& cache, VideoCore::QueryType type, VAddr cpu_addr, u8* host_ptr)
-    : VideoCommon::CachedQueryBase<HostCounter>{cpu_addr, host_ptr}, cache{&cache}, type{type} {}
+CachedQuery::CachedQuery(QueryCache& cache_, VideoCore::QueryType type_, VAddr cpu_addr,
+                         u8* host_ptr)
+    : CachedQueryBase<HostCounter>{cpu_addr, host_ptr}, cache{&cache_}, type{type_} {}

 CachedQuery::~CachedQuery() = default;

 CachedQuery::CachedQuery(CachedQuery&& rhs) noexcept
-    : VideoCommon::CachedQueryBase<HostCounter>(std::move(rhs)), cache{rhs.cache}, type{rhs.type} {}
+    : CachedQueryBase<HostCounter>(std::move(rhs)), cache{rhs.cache}, type{rhs.type} {}

 CachedQuery& CachedQuery::operator=(CachedQuery&& rhs) noexcept {
    cache = rhs.cache;
@@ -46,8 +46,8 @@ private:

 class HostCounter final : public VideoCommon::HostCounterBase<QueryCache, HostCounter> {
 public:
-    explicit HostCounter(QueryCache& cache, std::shared_ptr<HostCounter> dependency,
-                         VideoCore::QueryType type);
+    explicit HostCounter(QueryCache& cache_, std::shared_ptr<HostCounter> dependency,
+                         VideoCore::QueryType type_);
    ~HostCounter();

    void EndQuery();
@@ -62,7 +62,7 @@ private:

 class CachedQuery final : public VideoCommon::CachedQueryBase<HostCounter> {
 public:
-    explicit CachedQuery(QueryCache& cache, VideoCore::QueryType type, VAddr cpu_addr,
+    explicit CachedQuery(QueryCache& cache_, VideoCore::QueryType type_, VAddr cpu_addr,
                         u8* host_ptr);
    ~CachedQuery() override;

@@ -198,10 +198,10 @@ ProgramSharedPtr BuildShader(const Device& device, ShaderType shader_type, u64 u
    return program;
 }

-Shader::Shader(std::shared_ptr<VideoCommon::Shader::Registry> registry_, ShaderEntries entries_,
-               ProgramSharedPtr program_, bool is_built)
+Shader::Shader(std::shared_ptr<Registry> registry_, ShaderEntries entries_,
+               ProgramSharedPtr program_, bool is_built_)
    : registry{std::move(registry_)}, entries{std::move(entries_)}, program{std::move(program_)},
-      is_built(is_built) {
+      is_built{is_built_} {
    handle = program->assembly_program.handle;
    if (handle == 0) {
        handle = program->source_program.handle;
@@ -108,7 +108,7 @@ public:

 private:
    explicit Shader(std::shared_ptr<VideoCommon::Shader::Registry> registry, ShaderEntries entries,
-                    ProgramSharedPtr program, bool is_built = true);
+                    ProgramSharedPtr program, bool is_built_ = true);

    std::shared_ptr<VideoCommon::Shader::Registry> registry;
    ShaderEntries entries;
@@ -131,7 +131,7 @@ private:

 class Expression final {
 public:
-    Expression(std::string code, Type type) : code{std::move(code)}, type{type} {
+    Expression(std::string code_, Type type_) : code{std::move(code_)}, type{type_} {
        ASSERT(type != Type::Void);
    }
    Expression() : type{Type::Void} {}
@@ -148,8 +148,8 @@ public:
        ASSERT(type == Type::Void);
    }

-    std::string As(Type type) const {
-        switch (type) {
+    std::string As(Type type_) const {
+        switch (type_) {
        case Type::Bool:
            return AsBool();
        case Type::Bool2:
@@ -418,11 +418,12 @@ struct GenericVaryingDescription {

 class GLSLDecompiler final {
 public:
-    explicit GLSLDecompiler(const Device& device, const ShaderIR& ir, const Registry& registry,
-                            ShaderType stage, std::string_view identifier, std::string_view suffix)
-        : device{device}, ir{ir}, registry{registry}, stage{stage}, identifier{identifier},
-          suffix{suffix}, header{ir.GetHeader()}, use_unified_uniforms{
-                                                      UseUnifiedUniforms(device, ir, stage)} {
+    explicit GLSLDecompiler(const Device& device_, const ShaderIR& ir_, const Registry& registry_,
+                            ShaderType stage_, std::string_view identifier_,
+                            std::string_view suffix_)
+        : device{device_}, ir{ir_}, registry{registry_}, stage{stage_}, identifier{identifier_},
+          suffix{suffix_}, header{ir.GetHeader()}, use_unified_uniforms{
+                                                       UseUnifiedUniforms(device_, ir_, stage_)} {
        if (stage != ShaderType::Compute) {
            transform_feedback = BuildTransformFeedback(registry.GetGraphicsInfo());
        }
@@ -777,16 +778,16 @@ private:
            name = "gs_" + name + "[]";
        }

-        std::string suffix;
+        std::string suffix_;
        if (stage == ShaderType::Fragment) {
            const auto input_mode{header.ps.GetPixelImap(location)};
            if (input_mode == PixelImap::Unused) {
                return;
            }
-            suffix = GetInputFlags(input_mode);
+            suffix_ = GetInputFlags(input_mode);
        }

-        code.AddLine("layout (location = {}) {} in vec4 {};", location, suffix, name);
+        code.AddLine("layout (location = {}) {} in vec4 {};", location, suffix_, name);
    }

    void DeclareOutputAttributes() {
@@ -2100,13 +2101,13 @@ private:
        const auto type = meta.sampler.is_shadow ? Type::Float : Type::Int;
        const bool separate_dc = meta.sampler.is_shadow;

-        std::vector<TextureIR> ir;
+        std::vector<TextureIR> ir_;
        if (meta.sampler.is_shadow) {
-            ir = {TextureOffset{}};
+            ir_ = {TextureOffset{}};
        } else {
-            ir = {TextureOffset{}, TextureArgument{type, meta.component}};
+            ir_ = {TextureOffset{}, TextureArgument{type, meta.component}};
        }
-        return {GenerateTexture(operation, "Gather", ir, separate_dc) + GetSwizzle(meta.element),
+        return {GenerateTexture(operation, "Gather", ir_, separate_dc) + GetSwizzle(meta.element),
                Type::Float};
    }

@@ -2801,7 +2802,7 @@ std::string GetFlowVariable(u32 index) {

 class ExprDecompiler {
 public:
-    explicit ExprDecompiler(GLSLDecompiler& decomp) : decomp{decomp} {}
+    explicit ExprDecompiler(GLSLDecompiler& decomp_) : decomp{decomp_} {}

    void operator()(const ExprAnd& expr) {
        inner += '(';
@@ -2856,7 +2857,7 @@ private:

 class ASTDecompiler {
 public:
-    explicit ASTDecompiler(GLSLDecompiler& decomp) : decomp{decomp} {}
+    explicit ASTDecompiler(GLSLDecompiler& decomp_) : decomp{decomp_} {}

    void operator()(const ASTProgram& ast) {
        ASTNode current = ast.nodes.GetFirst();
@@ -25,8 +25,8 @@ using ImageEntry = VideoCommon::Shader::Image;

 class ConstBufferEntry : public VideoCommon::Shader::ConstBuffer {
 public:
-    explicit ConstBufferEntry(u32 max_offset, bool is_indirect, u32 index)
-        : VideoCommon::Shader::ConstBuffer{max_offset, is_indirect}, index{index} {}
+    explicit ConstBufferEntry(u32 max_offset, bool is_indirect, u32 index_)
+        : ConstBuffer{max_offset, is_indirect}, index{index_} {}

    u32 GetIndex() const {
        return index;
@@ -37,10 +37,10 @@ private:
 };

 struct GlobalMemoryEntry {
-    constexpr explicit GlobalMemoryEntry(u32 cbuf_index, u32 cbuf_offset, bool is_read,
-                                         bool is_written)
-        : cbuf_index{cbuf_index}, cbuf_offset{cbuf_offset}, is_read{is_read}, is_written{
-                                                                                  is_written} {}
+    constexpr explicit GlobalMemoryEntry(u32 cbuf_index_, u32 cbuf_offset_, bool is_read_,
+                                         bool is_written_)
+        : cbuf_index{cbuf_index_}, cbuf_offset{cbuf_offset_}, is_read{is_read_}, is_written{
+                                                                                     is_written_} {}

    u32 cbuf_index = 0;
    u32 cbuf_offset = 0;
@@ -258,9 +258,9 @@ constexpr u32 EncodeSwizzle(SwizzleSource x_source, SwizzleSource y_source, Swiz

 } // Anonymous namespace

-CachedSurface::CachedSurface(const GPUVAddr gpu_addr, const SurfaceParams& params,
-                             bool is_astc_supported)
-    : VideoCommon::SurfaceBase<View>(gpu_addr, params, is_astc_supported) {
+CachedSurface::CachedSurface(const GPUVAddr gpu_addr_, const SurfaceParams& params_,
+                             bool is_astc_supported_)
+    : SurfaceBase<View>{gpu_addr_, params_, is_astc_supported_} {
    if (is_converted) {
        internal_format = params.srgb_conversion ? GL_SRGB8_ALPHA8 : GL_RGBA8;
        format = GL_RGBA;
@@ -419,11 +419,11 @@ View CachedSurface::CreateViewInner(const ViewParams& view_key, const bool is_pr
    return view;
 }

-CachedSurfaceView::CachedSurfaceView(CachedSurface& surface, const ViewParams& params,
-                                     bool is_proxy)
-    : VideoCommon::ViewBase(params), surface{surface}, format{surface.internal_format},
-      target{GetTextureTarget(params.target)}, is_proxy{is_proxy} {
-    if (!is_proxy) {
+CachedSurfaceView::CachedSurfaceView(CachedSurface& surface_, const ViewParams& params_,
+                                     bool is_proxy_)
+    : ViewBase{params_}, surface{surface_}, format{surface_.internal_format},
+      target{GetTextureTarget(params_.target)}, is_proxy{is_proxy_} {
+    if (!is_proxy_) {
        main_view = CreateTextureView();
    }
 }
@@ -493,13 +493,13 @@ GLuint CachedSurfaceView::GetTexture(SwizzleSource x_source, SwizzleSource y_sou

    std::array swizzle{x_source, y_source, z_source, w_source};

-    switch (const PixelFormat format = GetSurfaceParams().pixel_format) {
+    switch (const PixelFormat pixel_format = GetSurfaceParams().pixel_format) {
    case PixelFormat::D24_UNORM_S8_UINT:
    case PixelFormat::D32_FLOAT_S8_UINT:
    case PixelFormat::S8_UINT_D24_UNORM:
        UNIMPLEMENTED_IF(x_source != SwizzleSource::R && x_source != SwizzleSource::G);
        glTextureParameteri(view.handle, GL_DEPTH_STENCIL_TEXTURE_MODE,
-                            GetComponent(format, x_source == SwizzleSource::R));
+                            GetComponent(pixel_format, x_source == SwizzleSource::R));

        // Make sure we sample the first component
        std::transform(swizzle.begin(), swizzle.end(), swizzle.begin(), [](SwizzleSource value) {
@@ -37,7 +37,8 @@ class CachedSurface final : public VideoCommon::SurfaceBase<View> {
    friend CachedSurfaceView;

 public:
-    explicit CachedSurface(GPUVAddr gpu_addr, const SurfaceParams& params, bool is_astc_supported);
+    explicit CachedSurface(GPUVAddr gpu_addr_, const SurfaceParams& params_,
+                           bool is_astc_supported_);
    ~CachedSurface();

    void UploadTexture(const std::vector<u8>& staging_buffer) override;
@@ -77,7 +78,7 @@ private:

 class CachedSurfaceView final : public VideoCommon::ViewBase {
 public:
-    explicit CachedSurfaceView(CachedSurface& surface, const ViewParams& params, bool is_proxy);
+    explicit CachedSurfaceView(CachedSurface& surface_, const ViewParams& params_, bool is_proxy_);
    ~CachedSurfaceView();

    /// @brief Attaches this texture view to the currently bound fb_target framebuffer
@@ -275,9 +275,9 @@ void RendererOpenGL::AddTelemetryFields() {
    LOG_INFO(Render_OpenGL, "GL_RENDERER: {}", gpu_model);

    constexpr auto user_system = Common::Telemetry::FieldType::UserSystem;
-    telemetry_session.AddField(user_system, "GPU_Vendor", gpu_vendor);
-    telemetry_session.AddField(user_system, "GPU_Model", gpu_model);
-    telemetry_session.AddField(user_system, "GPU_OpenGL_Version", gl_version);
+    telemetry_session.AddField(user_system, "GPU_Vendor", std::string(gpu_vendor));
+    telemetry_session.AddField(user_system, "GPU_Model", std::string(gpu_model));
+    telemetry_session.AddField(user_system, "GPU_OpenGL_Version", std::string(gl_version));
 }

 void RendererOpenGL::CreateRasterizer() {
@@ -243,8 +243,8 @@ std::string BuildCommaSeparatedExtensions(std::vector<std::string> available_ext
 RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
                               Core::Frontend::EmuWindow& emu_window,
                               Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu_,
-                               std::unique_ptr<Core::Frontend::GraphicsContext> context)
-    : RendererBase{emu_window, std::move(context)}, telemetry_session{telemetry_session_},
+                               std::unique_ptr<Core::Frontend::GraphicsContext> context_)
+    : RendererBase{emu_window, std::move(context_)}, telemetry_session{telemetry_session_},
      cpu_memory{cpu_memory_}, gpu{gpu_} {}

 RendererVulkan::~RendererVulkan() {
@@ -45,9 +45,9 @@ struct VKScreenInfo {
 class RendererVulkan final : public VideoCore::RendererBase {
 public:
    explicit RendererVulkan(Core::TelemetrySession& telemtry_session,
-                            Core::Frontend::EmuWindow& emu_window, Core::Memory::Memory& cpu_memory,
-                            Tegra::GPU& gpu,
-                            std::unique_ptr<Core::Frontend::GraphicsContext> context);
+                            Core::Frontend::EmuWindow& emu_window,
+                            Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu_,
+                            std::unique_ptr<Core::Frontend::GraphicsContext> context_);
    ~RendererVulkan() override;

    bool Init() override;
@@ -17,8 +17,8 @@ struct CommandPool::Pool {
    vk::CommandBuffers cmdbufs;
 };

-CommandPool::CommandPool(MasterSemaphore& master_semaphore, const VKDevice& device)
-    : ResourcePool(master_semaphore, COMMAND_BUFFER_POOL_SIZE), device{device} {}
+CommandPool::CommandPool(MasterSemaphore& master_semaphore, const VKDevice& device_)
+    : ResourcePool(master_semaphore, COMMAND_BUFFER_POOL_SIZE), device{device_} {}

 CommandPool::~CommandPool() = default;

@@ -17,7 +17,7 @@ class VKDevice;

 class CommandPool final : public ResourcePool {
 public:
-    explicit CommandPool(MasterSemaphore& master_semaphore, const VKDevice& device);
+    explicit CommandPool(MasterSemaphore& master_semaphore, const VKDevice& device_);
    ~CommandPool() override;

    void Allocate(size_t begin, size_t end) override;
@@ -461,15 +461,15 @@ VkDescriptorSet VKComputePass::CommitDescriptorSet(
    return set;
 }

-QuadArrayPass::QuadArrayPass(const VKDevice& device, VKScheduler& scheduler,
-                             VKDescriptorPool& descriptor_pool,
-                             VKStagingBufferPool& staging_buffer_pool,
-                             VKUpdateDescriptorQueue& update_descriptor_queue)
-    : VKComputePass(device, descriptor_pool, BuildQuadArrayPassDescriptorSetLayoutBinding(),
+QuadArrayPass::QuadArrayPass(const VKDevice& device_, VKScheduler& scheduler_,
+                             VKDescriptorPool& descriptor_pool_,
+                             VKStagingBufferPool& staging_buffer_pool_,
+                             VKUpdateDescriptorQueue& update_descriptor_queue_)
+    : VKComputePass(device_, descriptor_pool_, BuildQuadArrayPassDescriptorSetLayoutBinding(),
                    BuildQuadArrayPassDescriptorUpdateTemplateEntry(),
                    BuildComputePushConstantRange(sizeof(u32)), std::size(quad_array), quad_array),
-      scheduler{scheduler}, staging_buffer_pool{staging_buffer_pool},
-      update_descriptor_queue{update_descriptor_queue} {}
+      scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
+      update_descriptor_queue{update_descriptor_queue_} {}

 QuadArrayPass::~QuadArrayPass() = default;

@@ -510,14 +510,14 @@ std::pair<VkBuffer, VkDeviceSize> QuadArrayPass::Assemble(u32 num_vertices, u32
    return {*buffer.handle, 0};
 }

-Uint8Pass::Uint8Pass(const VKDevice& device, VKScheduler& scheduler,
-                     VKDescriptorPool& descriptor_pool, VKStagingBufferPool& staging_buffer_pool,
-                     VKUpdateDescriptorQueue& update_descriptor_queue)
-    : VKComputePass(device, descriptor_pool, BuildInputOutputDescriptorSetBindings(),
+Uint8Pass::Uint8Pass(const VKDevice& device_, VKScheduler& scheduler_,
+                     VKDescriptorPool& descriptor_pool_, VKStagingBufferPool& staging_buffer_pool_,
+                     VKUpdateDescriptorQueue& update_descriptor_queue_)
+    : VKComputePass(device_, descriptor_pool_, BuildInputOutputDescriptorSetBindings(),
                    BuildInputOutputDescriptorUpdateTemplate(), {}, std::size(uint8_pass),
                    uint8_pass),
-      scheduler{scheduler}, staging_buffer_pool{staging_buffer_pool},
-      update_descriptor_queue{update_descriptor_queue} {}
+      scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
+      update_descriptor_queue{update_descriptor_queue_} {}

 Uint8Pass::~Uint8Pass() = default;

@@ -555,16 +555,16 @@ std::pair<VkBuffer, u64> Uint8Pass::Assemble(u32 num_vertices, VkBuffer src_buff
    return {*buffer.handle, 0};
 }

-QuadIndexedPass::QuadIndexedPass(const VKDevice& device, VKScheduler& scheduler,
-                                 VKDescriptorPool& descriptor_pool,
-                                 VKStagingBufferPool& staging_buffer_pool,
-                                 VKUpdateDescriptorQueue& update_descriptor_queue)
-    : VKComputePass(device, descriptor_pool, BuildInputOutputDescriptorSetBindings(),
+QuadIndexedPass::QuadIndexedPass(const VKDevice& device_, VKScheduler& scheduler_,
+                                 VKDescriptorPool& descriptor_pool_,
+                                 VKStagingBufferPool& staging_buffer_pool_,
+                                 VKUpdateDescriptorQueue& update_descriptor_queue_)
+    : VKComputePass(device_, descriptor_pool_, BuildInputOutputDescriptorSetBindings(),
                    BuildInputOutputDescriptorUpdateTemplate(),
                    BuildComputePushConstantRange(sizeof(u32) * 2), std::size(QUAD_INDEXED_SPV),
                    QUAD_INDEXED_SPV),
-      scheduler{scheduler}, staging_buffer_pool{staging_buffer_pool},
-      update_descriptor_queue{update_descriptor_queue} {}
+      scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
+      update_descriptor_queue{update_descriptor_queue_} {}

 QuadIndexedPass::~QuadIndexedPass() = default;

@@ -43,10 +43,10 @@ private:

 class QuadArrayPass final : public VKComputePass {
 public:
-    explicit QuadArrayPass(const VKDevice& device, VKScheduler& scheduler,
-                           VKDescriptorPool& descriptor_pool,
-                           VKStagingBufferPool& staging_buffer_pool,
-                           VKUpdateDescriptorQueue& update_descriptor_queue);
+    explicit QuadArrayPass(const VKDevice& device_, VKScheduler& scheduler_,
+                           VKDescriptorPool& descriptor_pool_,
+                           VKStagingBufferPool& staging_buffer_pool_,
+                           VKUpdateDescriptorQueue& update_descriptor_queue_);
    ~QuadArrayPass();

    std::pair<VkBuffer, VkDeviceSize> Assemble(u32 num_vertices, u32 first);
@@ -59,9 +59,10 @@ private:

 class Uint8Pass final : public VKComputePass {
 public:
-    explicit Uint8Pass(const VKDevice& device, VKScheduler& scheduler,
-                       VKDescriptorPool& descriptor_pool, VKStagingBufferPool& staging_buffer_pool,
-                       VKUpdateDescriptorQueue& update_descriptor_queue);
+    explicit Uint8Pass(const VKDevice& device_, VKScheduler& scheduler_,
+                       VKDescriptorPool& descriptor_pool_,
+                       VKStagingBufferPool& staging_buffer_pool_,
+                       VKUpdateDescriptorQueue& update_descriptor_queue_);
    ~Uint8Pass();

    std::pair<VkBuffer, u64> Assemble(u32 num_vertices, VkBuffer src_buffer, u64 src_offset);
@@ -74,10 +75,10 @@ private:

 class QuadIndexedPass final : public VKComputePass {
 public:
-    explicit QuadIndexedPass(const VKDevice& device, VKScheduler& scheduler,
-                             VKDescriptorPool& descriptor_pool,
-                             VKStagingBufferPool& staging_buffer_pool,
-                             VKUpdateDescriptorQueue& update_descriptor_queue);
+    explicit QuadIndexedPass(const VKDevice& device_, VKScheduler& scheduler_,
+                             VKDescriptorPool& descriptor_pool_,
+                             VKStagingBufferPool& staging_buffer_pool_,
+                             VKUpdateDescriptorQueue& update_descriptor_queue_);
    ~QuadIndexedPass();

    std::pair<VkBuffer, u64> Assemble(Tegra::Engines::Maxwell3D::Regs::IndexFormat index_format,
@@ -15,16 +15,16 @@

 namespace Vulkan {

-VKComputePipeline::VKComputePipeline(const VKDevice& device, VKScheduler& scheduler,
-                                     VKDescriptorPool& descriptor_pool,
-                                     VKUpdateDescriptorQueue& update_descriptor_queue,
-                                     const SPIRVShader& shader)
-    : device{device}, scheduler{scheduler}, entries{shader.entries},
+VKComputePipeline::VKComputePipeline(const VKDevice& device_, VKScheduler& scheduler_,
+                                     VKDescriptorPool& descriptor_pool_,
+                                     VKUpdateDescriptorQueue& update_descriptor_queue_,
+                                     const SPIRVShader& shader_)
+    : device{device_}, scheduler{scheduler_}, entries{shader_.entries},
      descriptor_set_layout{CreateDescriptorSetLayout()},
-      descriptor_allocator{descriptor_pool, *descriptor_set_layout},
-      update_descriptor_queue{update_descriptor_queue}, layout{CreatePipelineLayout()},
+      descriptor_allocator{descriptor_pool_, *descriptor_set_layout},
+      update_descriptor_queue{update_descriptor_queue_}, layout{CreatePipelineLayout()},
      descriptor_template{CreateDescriptorUpdateTemplate()},
-      shader_module{CreateShaderModule(shader.code)}, pipeline{CreatePipeline()} {}
+      shader_module{CreateShaderModule(shader_.code)}, pipeline{CreatePipeline()} {}

 VKComputePipeline::~VKComputePipeline() = default;

@@ -17,10 +17,10 @@ class VKUpdateDescriptorQueue;

 class VKComputePipeline final {
 public:
-    explicit VKComputePipeline(const VKDevice& device, VKScheduler& scheduler,
-                               VKDescriptorPool& descriptor_pool,
-                               VKUpdateDescriptorQueue& update_descriptor_queue,
-                               const SPIRVShader& shader);
+    explicit VKComputePipeline(const VKDevice& device_, VKScheduler& scheduler_,
+                               VKDescriptorPool& descriptor_pool_,
+                               VKUpdateDescriptorQueue& update_descriptor_queue_,
+                               const SPIRVShader& shader_);
    ~VKComputePipeline();

    VkDescriptorSet CommitDescriptorSet();
@@ -491,8 +491,8 @@ bool VKDevice::IsOptimalAstcSupported(const VkPhysicalDeviceFeatures& features)
        VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
        VK_FORMAT_FEATURE_TRANSFER_DST_BIT};
    for (const auto format : astc_formats) {
-        const auto format_properties{physical.GetFormatProperties(format)};
-        if (!(format_properties.optimalTilingFeatures & format_feature_usage)) {
+        const auto physical_format_properties{physical.GetFormatProperties(format)};
+        if ((physical_format_properties.optimalTilingFeatures & format_feature_usage) == 0) {
            return false;
        }
    }
@@ -644,8 +644,8 @@ std::vector<const char*> VKDevice::LoadExtensions() {
    VkPhysicalDeviceFeatures2KHR features;
    features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;

-    VkPhysicalDeviceProperties2KHR properties;
-    properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
+    VkPhysicalDeviceProperties2KHR physical_properties;
+    physical_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;

    if (has_khr_shader_float16_int8) {
        VkPhysicalDeviceFloat16Int8FeaturesKHR float16_int8_features;
@@ -670,8 +670,8 @@ std::vector<const char*> VKDevice::LoadExtensions() {
        subgroup_properties.sType =
            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT;
        subgroup_properties.pNext = nullptr;
-        properties.pNext = &subgroup_properties;
-        physical.GetProperties2KHR(properties);
+        physical_properties.pNext = &subgroup_properties;
+        physical.GetProperties2KHR(physical_properties);

        is_warp_potentially_bigger = subgroup_properties.maxSubgroupSize > GuestWarpSize;

@@ -695,8 +695,8 @@ std::vector<const char*> VKDevice::LoadExtensions() {
        VkPhysicalDeviceTransformFeedbackPropertiesEXT tfb_properties;
        tfb_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
        tfb_properties.pNext = nullptr;
-        properties.pNext = &tfb_properties;
-        physical.GetProperties2KHR(properties);
+        physical_properties.pNext = &tfb_properties;
+        physical.GetProperties2KHR(physical_properties);

        if (tfb_features.transformFeedback && tfb_features.geometryStreams &&
            tfb_properties.maxTransformFeedbackStreams >= 4 &&
@@ -14,12 +14,13 @@

 namespace Vulkan {

-InnerFence::InnerFence(const VKDevice& device, VKScheduler& scheduler, u32 payload, bool is_stubbed)
-    : VideoCommon::FenceBase(payload, is_stubbed), device{device}, scheduler{scheduler} {}
+InnerFence::InnerFence(const VKDevice& device_, VKScheduler& scheduler_, u32 payload_,
+                       bool is_stubbed_)
+    : FenceBase{payload_, is_stubbed_}, device{device_}, scheduler{scheduler_} {}

-InnerFence::InnerFence(const VKDevice& device, VKScheduler& scheduler, GPUVAddr address,
-                       u32 payload, bool is_stubbed)
-    : VideoCommon::FenceBase(address, payload, is_stubbed), device{device}, scheduler{scheduler} {}
+InnerFence::InnerFence(const VKDevice& device_, VKScheduler& scheduler_, GPUVAddr address_,
+                       u32 payload_, bool is_stubbed_)
+    : FenceBase{address_, payload_, is_stubbed_}, device{device_}, scheduler{scheduler_} {}

 InnerFence::~InnerFence() = default;

@@ -71,11 +72,12 @@ bool InnerFence::IsEventSignalled() const {
    }
 }

-VKFenceManager::VKFenceManager(VideoCore::RasterizerInterface& rasterizer, Tegra::GPU& gpu,
-                               Tegra::MemoryManager& memory_manager, VKTextureCache& texture_cache,
-                               VKBufferCache& buffer_cache, VKQueryCache& query_cache,
-                               const VKDevice& device_, VKScheduler& scheduler_)
-    : GenericFenceManager(rasterizer, gpu, texture_cache, buffer_cache, query_cache),
+VKFenceManager::VKFenceManager(VideoCore::RasterizerInterface& rasterizer_, Tegra::GPU& gpu_,
+                               Tegra::MemoryManager& memory_manager_,
+                               VKTextureCache& texture_cache_, VKBufferCache& buffer_cache_,
+                               VKQueryCache& query_cache_, const VKDevice& device_,
+                               VKScheduler& scheduler_)
+    : GenericFenceManager{rasterizer_, gpu_, texture_cache_, buffer_cache_, query_cache_},
      device{device_}, scheduler{scheduler_} {}

 Fence VKFenceManager::CreateFence(u32 value, bool is_stubbed) {
@@ -28,10 +28,10 @@ class VKTextureCache;

 class InnerFence : public VideoCommon::FenceBase {
 public:
-    explicit InnerFence(const VKDevice& device, VKScheduler& scheduler, u32 payload,
-                        bool is_stubbed);
-    explicit InnerFence(const VKDevice& device, VKScheduler& scheduler, GPUVAddr address,
-                        u32 payload, bool is_stubbed);
+    explicit InnerFence(const VKDevice& device_, VKScheduler& scheduler_, u32 payload_,
+                        bool is_stubbed_);
+    explicit InnerFence(const VKDevice& device_, VKScheduler& scheduler_, GPUVAddr address_,
+                        u32 payload_, bool is_stubbed_);
    ~InnerFence();

    void Queue();
@@ -55,10 +55,10 @@ using GenericFenceManager =

 class VKFenceManager final : public GenericFenceManager {
 public:
-    explicit VKFenceManager(VideoCore::RasterizerInterface& rasterizer, Tegra::GPU& gpu,
-                            Tegra::MemoryManager& memory_manager, VKTextureCache& texture_cache,
-                            VKBufferCache& buffer_cache, VKQueryCache& query_cache,
-                            const VKDevice& device, VKScheduler& scheduler);
+    explicit VKFenceManager(VideoCore::RasterizerInterface& rasterizer_, Tegra::GPU& gpu_,
+                            Tegra::MemoryManager& memory_manager_, VKTextureCache& texture_cache_,
+                            VKBufferCache& buffer_cache_, VKQueryCache& query_cache_,
+                            const VKDevice& device_, VKScheduler& scheduler_);

 protected:
    Fence CreateFence(u32 value, bool is_stubbed) override;
@@ -71,21 +71,21 @@ VkViewportSwizzleNV UnpackViewportSwizzle(u16 swizzle) {

 } // Anonymous namespace

-VKGraphicsPipeline::VKGraphicsPipeline(const VKDevice& device, VKScheduler& scheduler,
-                                       VKDescriptorPool& descriptor_pool,
-                                       VKUpdateDescriptorQueue& update_descriptor_queue,
-                                       VKRenderPassCache& renderpass_cache,
-                                       const GraphicsPipelineCacheKey& key,
-                                       vk::Span<VkDescriptorSetLayoutBinding> bindings,
-                                       const SPIRVProgram& program)
-    : device{device}, scheduler{scheduler}, cache_key{key}, hash{cache_key.Hash()},
-      descriptor_set_layout{CreateDescriptorSetLayout(bindings)},
-      descriptor_allocator{descriptor_pool, *descriptor_set_layout},
-      update_descriptor_queue{update_descriptor_queue}, layout{CreatePipelineLayout()},
-      descriptor_template{CreateDescriptorUpdateTemplate(program)}, modules{CreateShaderModules(
-                                                                        program)},
-      renderpass{renderpass_cache.GetRenderPass(cache_key.renderpass_params)},
-      pipeline{CreatePipeline(cache_key.renderpass_params, program)} {}
+VKGraphicsPipeline::VKGraphicsPipeline(const VKDevice& device_, VKScheduler& scheduler_,
+                                       VKDescriptorPool& descriptor_pool_,
+                                       VKUpdateDescriptorQueue& update_descriptor_queue_,
+                                       VKRenderPassCache& renderpass_cache_,
+                                       const GraphicsPipelineCacheKey& key_,
+                                       vk::Span<VkDescriptorSetLayoutBinding> bindings_,
+                                       const SPIRVProgram& program_)
+    : device{device_}, scheduler{scheduler_}, cache_key{key_}, hash{cache_key.Hash()},
+      descriptor_set_layout{CreateDescriptorSetLayout(bindings_)},
+      descriptor_allocator{descriptor_pool_, *descriptor_set_layout},
+      update_descriptor_queue{update_descriptor_queue_}, layout{CreatePipelineLayout()},
+      descriptor_template{CreateDescriptorUpdateTemplate(program_)}, modules{CreateShaderModules(
+                                                                         program_)},
+      renderpass{renderpass_cache_.GetRenderPass(cache_key.renderpass_params)},
+      pipeline{CreatePipeline(cache_key.renderpass_params, program_)} {}

 VKGraphicsPipeline::~VKGraphicsPipeline() = default;

@@ -162,8 +162,8 @@ std::vector<vk::ShaderModule> VKGraphicsPipeline::CreateShaderModules(
        .codeSize = 0,
    };

-    std::vector<vk::ShaderModule> modules;
-    modules.reserve(Maxwell::MaxShaderStage);
+    std::vector<vk::ShaderModule> shader_modules;
+    shader_modules.reserve(Maxwell::MaxShaderStage);
    for (std::size_t i = 0; i < Maxwell::MaxShaderStage; ++i) {
        const auto& stage = program[i];
        if (!stage) {
@@ -174,9 +174,9 @@ std::vector<vk::ShaderModule> VKGraphicsPipeline::CreateShaderModules(

        ci.codeSize = stage->code.size() * sizeof(u32);
        ci.pCode = stage->code.data();
-        modules.push_back(device.GetLogical().CreateShaderModule(ci));
+        shader_modules.push_back(device.GetLogical().CreateShaderModule(ci));
    }
-    return modules;
+    return shader_modules;
 }

 vk::Pipeline VKGraphicsPipeline::CreatePipeline(const RenderPassParams& renderpass_params,
@@ -51,13 +51,13 @@ using SPIRVProgram = std::array<std::optional<SPIRVShader>, Maxwell::MaxShaderSt

 class VKGraphicsPipeline final {
 public:
-    explicit VKGraphicsPipeline(const VKDevice& device, VKScheduler& scheduler,
-                                VKDescriptorPool& descriptor_pool,
-                                VKUpdateDescriptorQueue& update_descriptor_queue,
-                                VKRenderPassCache& renderpass_cache,
-                                const GraphicsPipelineCacheKey& key,
-                                vk::Span<VkDescriptorSetLayoutBinding> bindings,
-                                const SPIRVProgram& program);
+    explicit VKGraphicsPipeline(const VKDevice& device_, VKScheduler& scheduler_,
+                                VKDescriptorPool& descriptor_pool_,
+                                VKUpdateDescriptorQueue& update_descriptor_queue_,
+                                VKRenderPassCache& renderpass_cache_,
+                                const GraphicsPipelineCacheKey& key_,
+                                vk::Span<VkDescriptorSetLayoutBinding> bindings_,
+                                const SPIRVProgram& program_);
    ~VKGraphicsPipeline();

    VkDescriptorSet CommitDescriptorSet();
@@ -13,18 +13,18 @@

 namespace Vulkan {

-VKImage::VKImage(const VKDevice& device, VKScheduler& scheduler, const VkImageCreateInfo& image_ci,
-                 VkImageAspectFlags aspect_mask)
-    : device{device}, scheduler{scheduler}, format{image_ci.format}, aspect_mask{aspect_mask},
-      image_num_layers{image_ci.arrayLayers}, image_num_levels{image_ci.mipLevels} {
-    UNIMPLEMENTED_IF_MSG(image_ci.queueFamilyIndexCount != 0,
+VKImage::VKImage(const VKDevice& device_, VKScheduler& scheduler_,
+                 const VkImageCreateInfo& image_ci_, VkImageAspectFlags aspect_mask_)
+    : device{device_}, scheduler{scheduler_}, format{image_ci_.format}, aspect_mask{aspect_mask_},
+      image_num_layers{image_ci_.arrayLayers}, image_num_levels{image_ci_.mipLevels} {
+    UNIMPLEMENTED_IF_MSG(image_ci_.queueFamilyIndexCount != 0,
                         "Queue family tracking is not implemented");

-    image = device.GetLogical().CreateImage(image_ci);
+    image = device_.GetLogical().CreateImage(image_ci_);

    const u32 num_ranges = image_num_layers * image_num_levels;
    barriers.resize(num_ranges);
-    subrange_states.resize(num_ranges, {{}, image_ci.initialLayout});
+    subrange_states.resize(num_ranges, {{}, image_ci_.initialLayout});
 }

 VKImage::~VKImage() = default;
@@ -17,8 +17,8 @@ class VKScheduler;

 class VKImage {
 public:
-    explicit VKImage(const VKDevice& device, VKScheduler& scheduler,
-                     const VkImageCreateInfo& image_ci, VkImageAspectFlags aspect_mask);
+    explicit VKImage(const VKDevice& device_, VKScheduler& scheduler_,
+                     const VkImageCreateInfo& image_ci_, VkImageAspectFlags aspect_mask_);
    ~VKImage();

    /// Records in the passed command buffer an image transition and updates the state of the image.
@@ -29,10 +29,10 @@ u64 GetAllocationChunkSize(u64 required_size) {

 class VKMemoryAllocation final {
 public:
-    explicit VKMemoryAllocation(const VKDevice& device, vk::DeviceMemory memory,
-                                VkMemoryPropertyFlags properties, u64 allocation_size, u32 type)
-        : device{device}, memory{std::move(memory)}, properties{properties},
-          allocation_size{allocation_size}, shifted_type{ShiftType(type)} {}
+    explicit VKMemoryAllocation(const VKDevice& device_, vk::DeviceMemory memory_,
+                                VkMemoryPropertyFlags properties_, u64 allocation_size_, u32 type_)
+        : device{device_}, memory{std::move(memory_)}, properties{properties_},
+          allocation_size{allocation_size_}, shifted_type{ShiftType(type_)} {}

    VKMemoryCommit Commit(VkDeviceSize commit_size, VkDeviceSize alignment) {
        auto found = TryFindFreeSection(free_iterator, allocation_size,
@@ -117,8 +117,8 @@ private:
    std::vector<const VKMemoryCommitImpl*> commits;
 };

-VKMemoryManager::VKMemoryManager(const VKDevice& device)
-    : device{device}, properties{device.GetPhysical().GetMemoryProperties()} {}
+VKMemoryManager::VKMemoryManager(const VKDevice& device_)
+    : device{device_}, properties{device_.GetPhysical().GetMemoryProperties()} {}

 VKMemoryManager::~VKMemoryManager() = default;

@@ -207,9 +207,9 @@ VKMemoryCommit VKMemoryManager::TryAllocCommit(const VkMemoryRequirements& requi
    return {};
 }

-VKMemoryCommitImpl::VKMemoryCommitImpl(const VKDevice& device, VKMemoryAllocation* allocation,
-                                       const vk::DeviceMemory& memory, u64 begin, u64 end)
-    : device{device}, memory{memory}, interval{begin, end}, allocation{allocation} {}
+VKMemoryCommitImpl::VKMemoryCommitImpl(const VKDevice& device_, VKMemoryAllocation* allocation_,
+                                       const vk::DeviceMemory& memory_, u64 begin_, u64 end_)
+    : device{device_}, memory{memory_}, interval{begin_, end_}, allocation{allocation_} {}

 VKMemoryCommitImpl::~VKMemoryCommitImpl() {
    allocation->Free(this);
@@ -21,7 +21,7 @@ using VKMemoryCommit = std::unique_ptr<VKMemoryCommitImpl>;

 class VKMemoryManager final {
 public:
-    explicit VKMemoryManager(const VKDevice& device);
+    explicit VKMemoryManager(const VKDevice& device_);
    VKMemoryManager(const VKMemoryManager&) = delete;
    ~VKMemoryManager();

@@ -58,8 +58,8 @@ class VKMemoryCommitImpl final {
    friend MemoryMap;

 public:
-    explicit VKMemoryCommitImpl(const VKDevice& device, VKMemoryAllocation* allocation,
-                                const vk::DeviceMemory& memory, u64 begin, u64 end);
+    explicit VKMemoryCommitImpl(const VKDevice& device_, VKMemoryAllocation* allocation_,
+                                const vk::DeviceMemory& memory_, u64 begin_, u64 end_);
    ~VKMemoryCommitImpl();

    /// Maps a memory region and returns a pointer to it.
@@ -93,8 +93,8 @@ private:
 /// Holds ownership of a memory map.
 class MemoryMap final {
 public:
-    explicit MemoryMap(const VKMemoryCommitImpl* commit, u8* address)
-        : commit{commit}, address{address} {}
+    explicit MemoryMap(const VKMemoryCommitImpl* commit_, u8* address_)
+        : commit{commit_}, address{address_} {}

    ~MemoryMap() {
        if (commit) {
@@ -66,15 +66,15 @@ void QueryPool::Reserve(std::pair<VkQueryPool, u32> query) {
    usage[pool_index * GROW_STEP + static_cast<std::ptrdiff_t>(query.second)] = false;
 }

-VKQueryCache::VKQueryCache(VideoCore::RasterizerInterface& rasterizer,
-                           Tegra::Engines::Maxwell3D& maxwell3d, Tegra::MemoryManager& gpu_memory,
-                           const VKDevice& device, VKScheduler& scheduler)
-    : VideoCommon::QueryCacheBase<VKQueryCache, CachedQuery, CounterStream,
-                                  HostCounter>{rasterizer, maxwell3d, gpu_memory},
-      device{device}, scheduler{scheduler}, query_pools{
-                                                QueryPool{device, scheduler,
-                                                          QueryType::SamplesPassed},
-                                            } {}
+VKQueryCache::VKQueryCache(VideoCore::RasterizerInterface& rasterizer_,
+                           Tegra::Engines::Maxwell3D& maxwell3d_, Tegra::MemoryManager& gpu_memory_,
+                           const VKDevice& device_, VKScheduler& scheduler_)
+    : QueryCacheBase<VKQueryCache, CachedQuery, CounterStream, HostCounter>{rasterizer_, maxwell3d_,
+                                                                            gpu_memory_},
+      device{device_}, scheduler{scheduler_}, query_pools{
+                                                  QueryPool{device_, scheduler_,
+                                                            QueryType::SamplesPassed},
+                                              } {}

 VKQueryCache::~VKQueryCache() {
    // TODO(Rodrigo): This is a hack to destroy all HostCounter instances before the base class
@@ -95,12 +95,12 @@ void VKQueryCache::Reserve(QueryType type, std::pair<VkQueryPool, u32> query) {
    query_pools[static_cast<std::size_t>(type)].Reserve(query);
 }

-HostCounter::HostCounter(VKQueryCache& cache, std::shared_ptr<HostCounter> dependency,
-                         QueryType type)
-    : VideoCommon::HostCounterBase<VKQueryCache, HostCounter>{std::move(dependency)}, cache{cache},
-      type{type}, query{cache.AllocateQuery(type)}, tick{cache.Scheduler().CurrentTick()} {
-    const vk::Device* logical = &cache.Device().GetLogical();
-    cache.Scheduler().Record([logical, query = query](vk::CommandBuffer cmdbuf) {
+HostCounter::HostCounter(VKQueryCache& cache_, std::shared_ptr<HostCounter> dependency_,
+                         QueryType type_)
+    : HostCounterBase<VKQueryCache, HostCounter>{std::move(dependency_)}, cache{cache_},
+      type{type_}, query{cache_.AllocateQuery(type_)}, tick{cache_.Scheduler().CurrentTick()} {
+    const vk::Device* logical = &cache_.Device().GetLogical();
+    cache_.Scheduler().Record([logical, query = query](vk::CommandBuffer cmdbuf) {
        logical->ResetQueryPoolEXT(query.first, query.second, 1);
        cmdbuf.BeginQuery(query.first, query.second, VK_QUERY_CONTROL_PRECISE_BIT);
    });
@@ -53,9 +53,9 @@ private:
 class VKQueryCache final
    : public VideoCommon::QueryCacheBase<VKQueryCache, CachedQuery, CounterStream, HostCounter> {
 public:
-    explicit VKQueryCache(VideoCore::RasterizerInterface& rasterizer,
-                          Tegra::Engines::Maxwell3D& maxwell3d, Tegra::MemoryManager& gpu_memory,
-                          const VKDevice& device, VKScheduler& scheduler);
+    explicit VKQueryCache(VideoCore::RasterizerInterface& rasterizer_,
+                          Tegra::Engines::Maxwell3D& maxwell3d_, Tegra::MemoryManager& gpu_memory_,
+                          const VKDevice& device_, VKScheduler& scheduler_);
    ~VKQueryCache();

    std::pair<VkQueryPool, u32> AllocateQuery(VideoCore::QueryType type);
@@ -78,8 +78,8 @@ private:

 class HostCounter final : public VideoCommon::HostCounterBase<VKQueryCache, HostCounter> {
 public:
-    explicit HostCounter(VKQueryCache& cache, std::shared_ptr<HostCounter> dependency,
-                         VideoCore::QueryType type);
+    explicit HostCounter(VKQueryCache& cache_, std::shared_ptr<HostCounter> dependency_,
+                         VideoCore::QueryType type_);
    ~HostCounter();

    void EndQuery();
@@ -904,15 +904,14 @@ void RasterizerVulkan::SetupShaderDescriptors(
    texture_cache.GuardSamplers(false);
 }

-void RasterizerVulkan::SetupImageTransitions(
-    Texceptions texceptions, const std::array<View, Maxwell::NumRenderTargets>& color_attachments,
-    const View& zeta_attachment) {
+void RasterizerVulkan::SetupImageTransitions(Texceptions texceptions, const ColorAttachments& color,
+                                             const ZetaAttachment& zeta) {
    TransitionImages(sampled_views, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_ACCESS_SHADER_READ_BIT);
    TransitionImages(image_views, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
                     VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT);

-    for (std::size_t rt = 0; rt < std::size(color_attachments); ++rt) {
-        const auto color_attachment = color_attachments[rt];
+    for (std::size_t rt = 0; rt < color.size(); ++rt) {
+        const auto color_attachment = color[rt];
        if (color_attachment == nullptr) {
            continue;
        }
@@ -923,13 +922,13 @@ void RasterizerVulkan::SetupImageTransitions(
                                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
    }

-    if (zeta_attachment != nullptr) {
+    if (zeta != nullptr) {
        const auto image_layout = texceptions[ZETA_TEXCEPTION_INDEX]
                                      ? VK_IMAGE_LAYOUT_GENERAL
                                      : VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
-        zeta_attachment->Transition(image_layout, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
-                                    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
-                                        VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
+        zeta->Transition(image_layout, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+                         VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
+                             VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
    }
 }

@@ -160,6 +160,9 @@ private:
        bool is_indexed = 0;
    };

+    using ColorAttachments = std::array<View, Maxwell::NumRenderTargets>;
+    using ZetaAttachment = View;
+
    using Texceptions = std::bitset<Maxwell::NumRenderTargets + 1>;

    static constexpr std::size_t ZETA_TEXCEPTION_INDEX = 8;
@@ -181,9 +184,8 @@ private:
    /// Setup descriptors in the graphics pipeline.
    void SetupShaderDescriptors(const std::array<Shader*, Maxwell::MaxShaderProgram>& shaders);

-    void SetupImageTransitions(Texceptions texceptions,
-                               const std::array<View, Maxwell::NumRenderTargets>& color_attachments,
-                               const View& zeta_attachment);
+    void SetupImageTransitions(Texceptions texceptions, const ColorAttachments& color,
+                               const ZetaAttachment& zeta);

    void UpdateDynamicStates();

@@ -308,8 +310,8 @@ private:
    vk::Event wfi_event;
    VideoCommon::Shader::AsyncShaders async_shaders;

-    std::array<View, Maxwell::NumRenderTargets> color_attachments;
-    View zeta_attachment;
+    ColorAttachments color_attachments;
+    ZetaAttachment zeta_attachment;

    std::vector<ImageView> sampled_views;
    std::vector<ImageView> image_views;
@@ -24,7 +24,7 @@ bool RenderPassParams::operator==(const RenderPassParams& rhs) const noexcept {
    return std::memcmp(&rhs, this, sizeof *this) == 0;
 }

-VKRenderPassCache::VKRenderPassCache(const VKDevice& device) : device{device} {}
+VKRenderPassCache::VKRenderPassCache(const VKDevice& device_) : device{device_} {}

 VKRenderPassCache::~VKRenderPassCache() = default;

@@ -55,7 +55,7 @@ namespace Vulkan {

 class VKRenderPassCache final {
 public:
-    explicit VKRenderPassCache(const VKDevice& device);
+    explicit VKRenderPassCache(const VKDevice& device_);
    ~VKRenderPassCache();

    VkRenderPass GetRenderPass(const RenderPassParams& params);
@@ -36,7 +36,7 @@ VkBorderColor ConvertBorderColor(std::array<float, 4> color) {

 } // Anonymous namespace

-VKSamplerCache::VKSamplerCache(const VKDevice& device) : device{device} {}
+VKSamplerCache::VKSamplerCache(const VKDevice& device_) : device{device_} {}

 VKSamplerCache::~VKSamplerCache() = default;

@@ -14,7 +14,7 @@ class VKDevice;

 class VKSamplerCache final : public VideoCommon::SamplerCache<VkSampler, vk::Sampler> {
 public:
-    explicit VKSamplerCache(const VKDevice& device);
+    explicit VKSamplerCache(const VKDevice& device_);
    ~VKSamplerCache();

 protected:
@@ -104,7 +104,7 @@ private:
    template <typename T>
    class TypedCommand final : public Command {
    public:
-        explicit TypedCommand(T&& command) : command{std::move(command)} {}
+        explicit TypedCommand(T&& command_) : command{std::move(command_)} {}
        ~TypedCommand() override = default;

        TypedCommand(TypedCommand&&) = delete;
@@ -55,8 +55,8 @@ enum class Type { Void, Bool, Bool2, Float, Int, Uint, HalfFloat };

 class Expression final {
 public:
-    Expression(Id id, Type type) : id{id}, type{type} {
-        ASSERT(type != Type::Void);
+    Expression(Id id_, Type type_) : id{id_}, type{type_} {
+        ASSERT(type_ != Type::Void);
    }
    Expression() : type{Type::Void} {}

@@ -281,12 +281,12 @@ u32 ShaderVersion(const VKDevice& device) {

 class SPIRVDecompiler final : public Sirit::Module {
 public:
-    explicit SPIRVDecompiler(const VKDevice& device, const ShaderIR& ir, ShaderType stage,
-                             const Registry& registry, const Specialization& specialization)
-        : Module(ShaderVersion(device)), device{device}, ir{ir}, stage{stage},
-          header{ir.GetHeader()}, registry{registry}, specialization{specialization} {
-        if (stage != ShaderType::Compute) {
-            transform_feedback = BuildTransformFeedback(registry.GetGraphicsInfo());
+    explicit SPIRVDecompiler(const VKDevice& device_, const ShaderIR& ir_, ShaderType stage_,
+                             const Registry& registry_, const Specialization& specialization_)
+        : Module(ShaderVersion(device_)), device{device_}, ir{ir_}, stage{stage_},
+          header{ir_.GetHeader()}, registry{registry_}, specialization{specialization_} {
+        if (stage_ != ShaderType::Compute) {
+            transform_feedback = BuildTransformFeedback(registry_.GetGraphicsInfo());
        }

        AddCapability(spv::Capability::Shader);
@@ -330,7 +330,7 @@ public:
        if (device.IsFloat16Supported()) {
            AddCapability(spv::Capability::Float16);
        }
-        t_scalar_half = Name(TypeFloat(device.IsFloat16Supported() ? 16 : 32), "scalar_half");
+        t_scalar_half = Name(TypeFloat(device_.IsFloat16Supported() ? 16 : 32), "scalar_half");
        t_half = Name(TypeVector(t_scalar_half, 2), "half");

        const Id main = Decompile();
@@ -1088,9 +1088,9 @@ private:
            indices.point_size = AddBuiltIn(t_float, spv::BuiltIn::PointSize, "point_size");
        }

-        const auto& output_attributes = ir.GetOutputAttributes();
-        const bool declare_clip_distances =
-            std::any_of(output_attributes.begin(), output_attributes.end(), [](const auto& index) {
+        const auto& ir_output_attributes = ir.GetOutputAttributes();
+        const bool declare_clip_distances = std::any_of(
+            ir_output_attributes.begin(), ir_output_attributes.end(), [](const auto& index) {
                return index == Attribute::Index::ClipDistances0123 ||
                       index == Attribute::Index::ClipDistances4567;
            });
@@ -2891,7 +2891,7 @@ private:

 class ExprDecompiler {
 public:
-    explicit ExprDecompiler(SPIRVDecompiler& decomp) : decomp{decomp} {}
+    explicit ExprDecompiler(SPIRVDecompiler& decomp_) : decomp{decomp_} {}

    Id operator()(const ExprAnd& expr) {
        const Id type_def = decomp.GetTypeDefinition(Type::Bool);
@@ -2947,7 +2947,7 @@ private:

 class ASTDecompiler {
 public:
-    explicit ASTDecompiler(SPIRVDecompiler& decomp) : decomp{decomp} {}
+    explicit ASTDecompiler(SPIRVDecompiler& decomp_) : decomp{decomp_} {}

    void operator()(const ASTProgram& ast) {
        ASTNode current = ast.nodes.GetFirst();
@@ -30,8 +30,8 @@ constexpr u32 DESCRIPTOR_SET = 0;

 class ConstBufferEntry : public VideoCommon::Shader::ConstBuffer {
 public:
-    explicit constexpr ConstBufferEntry(const VideoCommon::Shader::ConstBuffer& entry, u32 index)
-        : VideoCommon::Shader::ConstBuffer{entry}, index{index} {}
+    explicit constexpr ConstBufferEntry(const ConstBuffer& entry_, u32 index_)
+        : ConstBuffer{entry_}, index{index_} {}

    constexpr u32 GetIndex() const {
        return index;
@@ -43,8 +43,8 @@ private:

 class GlobalBufferEntry {
 public:
-    constexpr explicit GlobalBufferEntry(u32 cbuf_index, u32 cbuf_offset, bool is_written)
-        : cbuf_index{cbuf_index}, cbuf_offset{cbuf_offset}, is_written{is_written} {}
+    constexpr explicit GlobalBufferEntry(u32 cbuf_index_, u32 cbuf_offset_, bool is_written_)
+        : cbuf_index{cbuf_index_}, cbuf_offset{cbuf_offset_}, is_written{is_written_} {}

    constexpr u32 GetCbufIndex() const {
        return cbuf_index;
@@ -180,19 +180,19 @@ VkImageCreateInfo GenerateImageCreateInfo(const VKDevice& device, const SurfaceP
    return ci;
 }

-u32 EncodeSwizzle(Tegra::Texture::SwizzleSource x_source, Tegra::Texture::SwizzleSource y_source,
-                  Tegra::Texture::SwizzleSource z_source, Tegra::Texture::SwizzleSource w_source) {
+u32 EncodeSwizzle(SwizzleSource x_source, SwizzleSource y_source, SwizzleSource z_source,
+                  SwizzleSource w_source) {
    return (static_cast<u32>(x_source) << 24) | (static_cast<u32>(y_source) << 16) |
           (static_cast<u32>(z_source) << 8) | static_cast<u32>(w_source);
 }

 } // Anonymous namespace

-CachedSurface::CachedSurface(const VKDevice& device, VKMemoryManager& memory_manager,
-                             VKScheduler& scheduler, VKStagingBufferPool& staging_pool,
-                             GPUVAddr gpu_addr, const SurfaceParams& params)
-    : SurfaceBase<View>{gpu_addr, params, device.IsOptimalAstcSupported()}, device{device},
-      memory_manager{memory_manager}, scheduler{scheduler}, staging_pool{staging_pool} {
+CachedSurface::CachedSurface(const VKDevice& device_, VKMemoryManager& memory_manager_,
+                             VKScheduler& scheduler_, VKStagingBufferPool& staging_pool_,
+                             GPUVAddr gpu_addr_, const SurfaceParams& params_)
+    : SurfaceBase<View>{gpu_addr_, params_, device_.IsOptimalAstcSupported()}, device{device_},
+      memory_manager{memory_manager_}, scheduler{scheduler_}, staging_pool{staging_pool_} {
    if (params.IsBuffer()) {
        buffer = CreateBuffer(device, params, host_memory_size);
        commit = memory_manager.Commit(buffer, false);
@@ -234,7 +234,7 @@ void CachedSurface::UploadTexture(const std::vector<u8>& staging_buffer) {
 void CachedSurface::DownloadTexture(std::vector<u8>& staging_buffer) {
    UNIMPLEMENTED_IF(params.IsBuffer());

-    if (params.pixel_format == VideoCore::Surface::PixelFormat::A1B5G5R5_UNORM) {
+    if (params.pixel_format == PixelFormat::A1B5G5R5_UNORM) {
        LOG_WARNING(Render_Vulkan, "A1B5G5R5 flushing is stubbed");
    }

@@ -244,10 +244,10 @@ void CachedSurface::DownloadTexture(std::vector<u8>& staging_buffer) {
    FullTransition(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_ACCESS_TRANSFER_READ_BIT,
                   VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);

-    const auto& buffer = staging_pool.GetUnusedBuffer(host_memory_size, true);
+    const auto& unused_buffer = staging_pool.GetUnusedBuffer(host_memory_size, true);
    // TODO(Rodrigo): Do this in a single copy
    for (u32 level = 0; level < params.num_levels; ++level) {
-        scheduler.Record([image = *image->GetHandle(), buffer = *buffer.handle,
+        scheduler.Record([image = *image->GetHandle(), buffer = *unused_buffer.handle,
                          copy = GetBufferImageCopy(level)](vk::CommandBuffer cmdbuf) {
            cmdbuf.CopyImageToBuffer(image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer, copy);
        });
@@ -255,16 +255,17 @@ void CachedSurface::DownloadTexture(std::vector<u8>& staging_buffer) {
    scheduler.Finish();

    // TODO(Rodrigo): Use an intern buffer for staging buffers and avoid this unnecessary memcpy.
-    std::memcpy(staging_buffer.data(), buffer.commit->Map(host_memory_size), host_memory_size);
+    std::memcpy(staging_buffer.data(), unused_buffer.commit->Map(host_memory_size),
+                host_memory_size);
 }

 void CachedSurface::DecorateSurfaceName() {
    // TODO(Rodrigo): Add name decorations
 }

-View CachedSurface::CreateView(const ViewParams& params) {
+View CachedSurface::CreateView(const ViewParams& view_params) {
    // TODO(Rodrigo): Add name decorations
-    return views[params] = std::make_shared<CachedSurfaceView>(device, *this, params);
+    return views[view_params] = std::make_shared<CachedSurfaceView>(device, *this, view_params);
 }

 void CachedSurface::UploadBuffer(const std::vector<u8>& staging_buffer) {
@@ -348,21 +349,21 @@ VkImageSubresourceRange CachedSurface::GetImageSubresourceRange() const {
            static_cast<u32>(params.GetNumLayers())};
 }

-CachedSurfaceView::CachedSurfaceView(const VKDevice& device, CachedSurface& surface,
-                                     const ViewParams& params)
-    : VideoCommon::ViewBase{params}, params{surface.GetSurfaceParams()},
-      image{surface.GetImageHandle()}, buffer_view{surface.GetBufferViewHandle()},
-      aspect_mask{surface.GetAspectMask()}, device{device}, surface{surface},
-      base_level{params.base_level}, num_levels{params.num_levels},
-      image_view_type{image ? GetImageViewType(params.target) : VK_IMAGE_VIEW_TYPE_1D} {
+CachedSurfaceView::CachedSurfaceView(const VKDevice& device_, CachedSurface& surface_,
+                                     const ViewParams& view_params_)
+    : ViewBase{view_params_}, surface_params{surface_.GetSurfaceParams()},
+      image{surface_.GetImageHandle()}, buffer_view{surface_.GetBufferViewHandle()},
+      aspect_mask{surface_.GetAspectMask()}, device{device_}, surface{surface_},
+      base_level{view_params_.base_level}, num_levels{view_params_.num_levels},
+      image_view_type{image ? GetImageViewType(view_params_.target) : VK_IMAGE_VIEW_TYPE_1D} {
    if (image_view_type == VK_IMAGE_VIEW_TYPE_3D) {
        base_layer = 0;
        num_layers = 1;
-        base_slice = params.base_layer;
-        num_slices = params.num_layers;
+        base_slice = view_params_.base_layer;
+        num_slices = view_params_.num_layers;
    } else {
-        base_layer = params.base_layer;
-        num_layers = params.num_layers;
+        base_layer = view_params_.base_layer;
+        num_layers = view_params_.num_layers;
    }
 }

@@ -384,7 +385,7 @@ VkImageView CachedSurfaceView::GetImageView(SwizzleSource x_source, SwizzleSourc

    std::array swizzle{MaxwellToVK::SwizzleSource(x_source), MaxwellToVK::SwizzleSource(y_source),
                       MaxwellToVK::SwizzleSource(z_source), MaxwellToVK::SwizzleSource(w_source)};
-    if (params.pixel_format == VideoCore::Surface::PixelFormat::A1B5G5R5_UNORM) {
+    if (surface_params.pixel_format == PixelFormat::A1B5G5R5_UNORM) {
        // A1B5G5R5 is implemented as A1R5G5B5, we have to change the swizzle here.
        std::swap(swizzle[0], swizzle[2]);
    }
@@ -395,12 +396,12 @@ VkImageView CachedSurfaceView::GetImageView(SwizzleSource x_source, SwizzleSourc
    if (aspect == (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {
        UNIMPLEMENTED_IF(x_source != SwizzleSource::R && x_source != SwizzleSource::G);
        const bool is_first = x_source == SwizzleSource::R;
-        switch (params.pixel_format) {
-        case VideoCore::Surface::PixelFormat::D24_UNORM_S8_UINT:
-        case VideoCore::Surface::PixelFormat::D32_FLOAT_S8_UINT:
+        switch (surface_params.pixel_format) {
+        case PixelFormat::D24_UNORM_S8_UINT:
+        case PixelFormat::D32_FLOAT_S8_UINT:
            aspect = is_first ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_STENCIL_BIT;
            break;
-        case VideoCore::Surface::PixelFormat::S8_UINT_D24_UNORM:
+        case PixelFormat::S8_UINT_D24_UNORM:
            aspect = is_first ? VK_IMAGE_ASPECT_STENCIL_BIT : VK_IMAGE_ASPECT_DEPTH_BIT;
            break;
        default:
@@ -417,7 +418,7 @@ VkImageView CachedSurfaceView::GetImageView(SwizzleSource x_source, SwizzleSourc

    if (image_view_type == VK_IMAGE_VIEW_TYPE_3D) {
        ASSERT(base_slice == 0);
-        ASSERT(num_slices == params.depth);
+        ASSERT(num_slices == surface_params.depth);
    }

    image_view = device.GetLogical().CreateImageView({
@@ -40,9 +40,9 @@ class CachedSurface final : public VideoCommon::SurfaceBase<View> {
    friend CachedSurfaceView;

 public:
-    explicit CachedSurface(const VKDevice& device, VKMemoryManager& memory_manager,
-                           VKScheduler& scheduler, VKStagingBufferPool& staging_pool,
-                           GPUVAddr gpu_addr, const SurfaceParams& params);
+    explicit CachedSurface(const VKDevice& device_, VKMemoryManager& memory_manager_,
+                           VKScheduler& scheduler_, VKStagingBufferPool& staging_pool_,
+                           GPUVAddr gpu_addr_, const SurfaceParams& params_);
    ~CachedSurface();

    void UploadTexture(const std::vector<u8>& staging_buffer) override;
@@ -84,7 +84,7 @@ public:
 protected:
    void DecorateSurfaceName();

-    View CreateView(const ViewParams& params) override;
+    View CreateView(const ViewParams& view_params) override;

 private:
    void UploadBuffer(const std::vector<u8>& staging_buffer);
@@ -110,8 +110,8 @@ private:

 class CachedSurfaceView final : public VideoCommon::ViewBase {
 public:
-    explicit CachedSurfaceView(const VKDevice& device, CachedSurface& surface,
-                               const ViewParams& params);
+    explicit CachedSurfaceView(const VKDevice& device_, CachedSurface& surface_,
+                               const ViewParams& view_params_);
    ~CachedSurfaceView();

    VkImageView GetImageView(Tegra::Texture::SwizzleSource x_source,
@@ -126,11 +126,11 @@ public:
    }

    u32 GetWidth() const {
-        return params.GetMipWidth(base_level);
+        return surface_params.GetMipWidth(base_level);
    }

    u32 GetHeight() const {
-        return params.GetMipHeight(base_level);
+        return surface_params.GetMipHeight(base_level);
    }

    u32 GetNumLayers() const {
@@ -169,7 +169,7 @@ public:

 private:
    // Store a copy of these values to avoid double dereference when reading them
-    const SurfaceParams params;
+    const SurfaceParams surface_params;
    const VkImage image;
    const VkBufferView buffer_view;
    const VkImageAspectFlags aspect_mask;
@@ -14,8 +14,8 @@

 namespace Vulkan {

-VKUpdateDescriptorQueue::VKUpdateDescriptorQueue(const VKDevice& device, VKScheduler& scheduler)
-    : device{device}, scheduler{scheduler} {}
+VKUpdateDescriptorQueue::VKUpdateDescriptorQueue(const VKDevice& device_, VKScheduler& scheduler_)
+    : device{device_}, scheduler{scheduler_} {}

 VKUpdateDescriptorQueue::~VKUpdateDescriptorQueue() = default;

@@ -31,7 +31,7 @@ struct DescriptorUpdateEntry {

 class VKUpdateDescriptorQueue final {
 public:
-    explicit VKUpdateDescriptorQueue(const VKDevice& device, VKScheduler& scheduler);
+    explicit VKUpdateDescriptorQueue(const VKDevice& device_, VKScheduler& scheduler_);
    ~VKUpdateDescriptorQueue();

    void TickFrame();
@@ -417,7 +417,7 @@ VkResult Free(VkDevice device, VkCommandPool handle, Span<VkCommandBuffer> buffe
 }

 Instance Instance::Create(u32 version, Span<const char*> layers, Span<const char*> extensions,
-                          InstanceDispatch& dld) noexcept {
+                          InstanceDispatch& dispatch) noexcept {
    const VkApplicationInfo application_info{
        .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
        .pNext = nullptr,
@@ -439,17 +439,17 @@ Instance Instance::Create(u32 version, Span<const char*> layers, Span<const char
    };

    VkInstance instance;
-    if (dld.vkCreateInstance(&ci, nullptr, &instance) != VK_SUCCESS) {
+    if (dispatch.vkCreateInstance(&ci, nullptr, &instance) != VK_SUCCESS) {
        // Failed to create the instance.
        return {};
    }
-    if (!Proc(dld.vkDestroyInstance, dld, "vkDestroyInstance", instance)) {
+    if (!Proc(dispatch.vkDestroyInstance, dispatch, "vkDestroyInstance", instance)) {
        // We successfully created an instance but the destroy function couldn't be loaded.
        // This is a good moment to panic.
        return {};
    }

-    return Instance(instance, dld);
+    return Instance(instance, dispatch);
 }

 std::optional<std::vector<VkPhysicalDevice>> Instance::EnumeratePhysicalDevices() {
@@ -540,7 +540,7 @@ std::vector<VkImage> SwapchainKHR::GetImages() const {

 Device Device::Create(VkPhysicalDevice physical_device, Span<VkDeviceQueueCreateInfo> queues_ci,
                      Span<const char*> enabled_extensions, const void* next,
-                      DeviceDispatch& dld) noexcept {
+                      DeviceDispatch& dispatch) noexcept {
    const VkDeviceCreateInfo ci{
        .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
        .pNext = next,
@@ -555,11 +555,11 @@ Device Device::Create(VkPhysicalDevice physical_device, Span<VkDeviceQueueCreate
    };

    VkDevice device;
-    if (dld.vkCreateDevice(physical_device, &ci, nullptr, &device) != VK_SUCCESS) {
+    if (dispatch.vkCreateDevice(physical_device, &ci, nullptr, &device) != VK_SUCCESS) {
        return {};
    }
-    Load(device, dld);
-    return Device(device, dld);
+    Load(device, dispatch);
+    return Device(device, dispatch);
 }

 Queue Device::GetQueue(u32 family_index) const noexcept {
@@ -52,7 +52,7 @@ public:

    /// Construct a span from a pointer and a size.
    /// This is inteded for subranges.
-    constexpr Span(const T* ptr, std::size_t num) noexcept : ptr{ptr}, num{num} {}
+    constexpr Span(const T* ptr_, std::size_t num_) noexcept : ptr{ptr_}, num{num_} {}

    /// Returns the data pointer by the span.
    constexpr const T* data() const noexcept {
@@ -469,9 +469,10 @@ public:
    PoolAllocations() = default;

    /// Construct an allocation. Errors are reported through IsOutOfPoolMemory().
-    explicit PoolAllocations(std::unique_ptr<AllocationType[]> allocations, std::size_t num,
-                             VkDevice device, PoolType pool, const DeviceDispatch& dld) noexcept
-        : allocations{std::move(allocations)}, num{num}, device{device}, pool{pool}, dld{&dld} {}
+    explicit PoolAllocations(std::unique_ptr<AllocationType[]> allocations_, std::size_t num_,
+                             VkDevice device_, PoolType pool_, const DeviceDispatch& dld_) noexcept
+        : allocations{std::move(allocations_)}, num{num_}, device{device_}, pool{pool_},
+          dld{&dld_} {}

    /// Copying Vulkan allocations is not supported and will never be.
    PoolAllocations(const PoolAllocations&) = delete;
@@ -565,7 +566,7 @@ class Instance : public Handle<VkInstance, NoOwner, InstanceDispatch> {
 public:
    /// Creates a Vulkan instance. Use "operator bool" for error handling.
    static Instance Create(u32 version, Span<const char*> layers, Span<const char*> extensions,
-                           InstanceDispatch& dld) noexcept;
+                           InstanceDispatch& dispatch) noexcept;

    /// Enumerates physical devices.
    /// @return Physical devices and an empty handle on failure.
@@ -581,7 +582,8 @@ public:
    constexpr Queue() noexcept = default;

    /// Construct a queue handle.
-    constexpr Queue(VkQueue queue, const DeviceDispatch& dld) noexcept : queue{queue}, dld{&dld} {}
+    constexpr Queue(VkQueue queue_, const DeviceDispatch& dld_) noexcept
+        : queue{queue_}, dld{&dld_} {}

    VkResult Submit(Span<VkSubmitInfo> submit_infos,
                    VkFence fence = VK_NULL_HANDLE) const noexcept {
@@ -720,7 +722,7 @@ class Device : public Handle<VkDevice, NoOwner, DeviceDispatch> {
 public:
    static Device Create(VkPhysicalDevice physical_device, Span<VkDeviceQueueCreateInfo> queues_ci,
                         Span<const char*> enabled_extensions, const void* next,
-                         DeviceDispatch& dld) noexcept;
+                         DeviceDispatch& dispatch) noexcept;

    Queue GetQueue(u32 family_index) const noexcept;

@@ -809,8 +811,9 @@ class PhysicalDevice {
 public:
    constexpr PhysicalDevice() noexcept = default;

-    constexpr PhysicalDevice(VkPhysicalDevice physical_device, const InstanceDispatch& dld) noexcept
-        : physical_device{physical_device}, dld{&dld} {}
+    constexpr PhysicalDevice(VkPhysicalDevice physical_device_,
+                             const InstanceDispatch& dld_) noexcept
+        : physical_device{physical_device_}, dld{&dld_} {}

    constexpr operator VkPhysicalDevice() const noexcept {
        return physical_device;
@@ -849,8 +852,8 @@ class CommandBuffer {
 public:
    CommandBuffer() noexcept = default;

-    explicit CommandBuffer(VkCommandBuffer handle, const DeviceDispatch& dld) noexcept
-        : handle{handle}, dld{&dld} {}
+    explicit CommandBuffer(VkCommandBuffer handle_, const DeviceDispatch& dld_) noexcept
+        : handle{handle_}, dld{&dld_} {}

    const VkCommandBuffer* address() const noexcept {
        return &handle;
@@ -241,10 +241,10 @@ std::pair<ParseResult, ParseInfo> ParseCode(CFGRebuildState& state, u32 address)
    ParseInfo parse_info{};
    SingleBranch single_branch{};

-    const auto insert_label = [](CFGRebuildState& state, u32 address) {
-        const auto pair = state.labels.emplace(address);
+    const auto insert_label = [](CFGRebuildState& rebuild_state, u32 label_address) {
+        const auto pair = rebuild_state.labels.emplace(label_address);
        if (pair.second) {
-            state.inspect_queries.push_back(address);
+            rebuild_state.inspect_queries.push_back(label_address);
        }
    };

@@ -358,9 +358,9 @@ u32 ShaderIR::DecodeImage(NodeBlock& bb, u32 pc) {
                             instr.suldst.GetStoreDataLayout() != StoreType::Bits64);

            auto descriptor = [this, instr] {
-                std::optional<Tegra::Engines::SamplerDescriptor> descriptor;
+                std::optional<Tegra::Engines::SamplerDescriptor> sampler_descriptor;
                if (instr.suldst.is_immediate) {
-                    descriptor =
+                    sampler_descriptor =
                        registry.ObtainBoundSampler(static_cast<u32>(instr.image.index.Value()));
                } else {
                    const Node image_register = GetRegister(instr.gpr39);
@@ -368,12 +368,12 @@ u32 ShaderIR::DecodeImage(NodeBlock& bb, u32 pc) {
                                                  static_cast<s64>(global_code.size()));
                    const auto buffer = std::get<1>(result);
                    const auto offset = std::get<2>(result);
-                    descriptor = registry.ObtainBindlessSampler(buffer, offset);
+                    sampler_descriptor = registry.ObtainBindlessSampler(buffer, offset);
                }
-                if (!descriptor) {
+                if (!sampler_descriptor) {
                    UNREACHABLE_MSG("Failed to obtain image descriptor");
                }
-                return *descriptor;
+                return *sampler_descriptor;
            }();

            const auto comp_mask = GetImageComponentMask(descriptor.format);
@@ -90,11 +90,11 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
                UNIMPLEMENTED_MSG("S2R WscaleFactorZ is not implemented");
                return Immediate(0U);
            case SystemVariable::Tid: {
-                Node value = Immediate(0);
-                value = BitfieldInsert(value, Operation(OperationCode::LocalInvocationIdX), 0, 9);
-                value = BitfieldInsert(value, Operation(OperationCode::LocalInvocationIdY), 16, 9);
-                value = BitfieldInsert(value, Operation(OperationCode::LocalInvocationIdZ), 26, 5);
-                return value;
+                Node val = Immediate(0);
+                val = BitfieldInsert(val, Operation(OperationCode::LocalInvocationIdX), 0, 9);
+                val = BitfieldInsert(val, Operation(OperationCode::LocalInvocationIdY), 16, 9);
+                val = BitfieldInsert(val, Operation(OperationCode::LocalInvocationIdZ), 26, 5);
+                return val;
            }
            case SystemVariable::TidX:
                return Operation(OperationCode::LocalInvocationIdX);
@@ -284,24 +284,26 @@ using TrackSampler = std::shared_ptr<TrackSamplerData>;

 struct Sampler {
    /// Bound samplers constructor
-    constexpr explicit Sampler(u32 index, u32 offset, Tegra::Shader::TextureType type,
-                               bool is_array, bool is_shadow, bool is_buffer, bool is_indexed)
-        : index{index}, offset{offset}, type{type}, is_array{is_array}, is_shadow{is_shadow},
-          is_buffer{is_buffer}, is_indexed{is_indexed} {}
+    constexpr explicit Sampler(u32 index_, u32 offset_, Tegra::Shader::TextureType type_,
+                               bool is_array_, bool is_shadow_, bool is_buffer_, bool is_indexed_)
+        : index{index_}, offset{offset_}, type{type_}, is_array{is_array_}, is_shadow{is_shadow_},
+          is_buffer{is_buffer_}, is_indexed{is_indexed_} {}

    /// Separate sampler constructor
-    constexpr explicit Sampler(u32 index, std::pair<u32, u32> offsets, std::pair<u32, u32> buffers,
-                               Tegra::Shader::TextureType type, bool is_array, bool is_shadow,
-                               bool is_buffer)
-        : index{index}, offset{offsets.first}, secondary_offset{offsets.second},
-          buffer{buffers.first}, secondary_buffer{buffers.second}, type{type}, is_array{is_array},
-          is_shadow{is_shadow}, is_buffer{is_buffer}, is_separated{true} {}
+    constexpr explicit Sampler(u32 index_, std::pair<u32, u32> offsets, std::pair<u32, u32> buffers,
+                               Tegra::Shader::TextureType type, bool is_array_, bool is_shadow_,
+                               bool is_buffer_)
+        : index{index_}, offset{offsets.first}, secondary_offset{offsets.second},
+          buffer{buffers.first}, secondary_buffer{buffers.second}, type{type}, is_array{is_array_},
+          is_shadow{is_shadow_}, is_buffer{is_buffer_}, is_separated{true} {}

    /// Bindless samplers constructor
-    constexpr explicit Sampler(u32 index, u32 offset, u32 buffer, Tegra::Shader::TextureType type,
-                               bool is_array, bool is_shadow, bool is_buffer, bool is_indexed)
-        : index{index}, offset{offset}, buffer{buffer}, type{type}, is_array{is_array},
-          is_shadow{is_shadow}, is_buffer{is_buffer}, is_bindless{true}, is_indexed{is_indexed} {}
+    constexpr explicit Sampler(u32 index_, u32 offset_, u32 buffer_,
+                               Tegra::Shader::TextureType type, bool is_array_, bool is_shadow_,
+                               bool is_buffer_, bool is_indexed_)
+        : index{index_}, offset{offset_}, buffer{buffer_}, type{type}, is_array{is_array_},
+          is_shadow{is_shadow_}, is_buffer{is_buffer_}, is_bindless{true}, is_indexed{is_indexed_} {
+    }

    u32 index = 0;            ///< Emulated index given for the this sampler.
    u32 offset = 0;           ///< Offset in the const buffer from where the sampler is being read.
@@ -341,12 +343,12 @@ struct BindlessSamplerNode {
 struct Image {
 public:
    /// Bound images constructor
-    constexpr explicit Image(u32 index, u32 offset, Tegra::Shader::ImageType type)
-        : index{index}, offset{offset}, type{type} {}
+    constexpr explicit Image(u32 index_, u32 offset_, Tegra::Shader::ImageType type_)
+        : index{index_}, offset{offset_}, type{type_} {}

    /// Bindless samplers constructor
-    constexpr explicit Image(u32 index, u32 offset, u32 buffer, Tegra::Shader::ImageType type)
-        : index{index}, offset{offset}, buffer{buffer}, type{type}, is_bindless{true} {}
+    constexpr explicit Image(u32 index_, u32 offset_, u32 buffer_, Tegra::Shader::ImageType type_)
+        : index{index_}, offset{offset_}, buffer{buffer_}, type{type_}, is_bindless{true} {}

    void MarkWrite() {
        is_written = true;
@@ -377,7 +379,7 @@ struct GlobalMemoryBase {
    u32 cbuf_index = 0;
    u32 cbuf_offset = 0;

-    bool operator<(const GlobalMemoryBase& rhs) const {
+    [[nodiscard]] bool operator<(const GlobalMemoryBase& rhs) const {
        return std::tie(cbuf_index, cbuf_offset) < std::tie(rhs.cbuf_index, rhs.cbuf_offset);
    }
 };
@@ -414,7 +416,7 @@ using Meta =

 class AmendNode {
 public:
-    std::optional<std::size_t> GetAmendIndex() const {
+    [[nodiscard]] std::optional<std::size_t> GetAmendIndex() const {
        if (amend_index == amend_null_index) {
            return std::nullopt;
        }
@@ -437,34 +439,34 @@ private:
 /// Holds any kind of operation that can be done in the IR
 class OperationNode final : public AmendNode {
 public:
-    explicit OperationNode(OperationCode code) : OperationNode(code, Meta{}) {}
+    explicit OperationNode(OperationCode code_) : OperationNode(code_, Meta{}) {}

-    explicit OperationNode(OperationCode code, Meta meta)
-        : OperationNode(code, std::move(meta), std::vector<Node>{}) {}
+    explicit OperationNode(OperationCode code_, Meta meta_)
+        : OperationNode(code_, std::move(meta_), std::vector<Node>{}) {}

-    explicit OperationNode(OperationCode code, std::vector<Node> operands)
-        : OperationNode(code, Meta{}, std::move(operands)) {}
+    explicit OperationNode(OperationCode code_, std::vector<Node> operands_)
+        : OperationNode(code_, Meta{}, std::move(operands_)) {}

-    explicit OperationNode(OperationCode code, Meta meta, std::vector<Node> operands)
-        : code{code}, meta{std::move(meta)}, operands{std::move(operands)} {}
+    explicit OperationNode(OperationCode code_, Meta meta_, std::vector<Node> operands_)
+        : code{code_}, meta{std::move(meta_)}, operands{std::move(operands_)} {}

    template <typename... Args>
-    explicit OperationNode(OperationCode code, Meta meta, Args&&... operands)
-        : code{code}, meta{std::move(meta)}, operands{operands...} {}
+    explicit OperationNode(OperationCode code_, Meta meta_, Args&&... operands_)
+        : code{code_}, meta{std::move(meta_)}, operands{operands_...} {}

-    OperationCode GetCode() const {
+    [[nodiscard]] OperationCode GetCode() const {
        return code;
    }

-    const Meta& GetMeta() const {
+    [[nodiscard]] const Meta& GetMeta() const {
        return meta;
    }

-    std::size_t GetOperandsCount() const {
+    [[nodiscard]] std::size_t GetOperandsCount() const {
        return operands.size();
    }

-    const Node& operator[](std::size_t operand_index) const {
+    [[nodiscard]] const Node& operator[](std::size_t operand_index) const {
        return operands.at(operand_index);
    }

@@ -477,14 +479,14 @@ private:
 /// Encloses inside any kind of node that returns a boolean conditionally-executed code
 class ConditionalNode final : public AmendNode {
 public:
-    explicit ConditionalNode(Node condition, std::vector<Node>&& code)
-        : condition{std::move(condition)}, code{std::move(code)} {}
+    explicit ConditionalNode(Node condition_, std::vector<Node>&& code_)
+        : condition{std::move(condition_)}, code{std::move(code_)} {}

-    const Node& GetCondition() const {
+    [[nodiscard]] const Node& GetCondition() const {
        return condition;
    }

-    const std::vector<Node>& GetCode() const {
+    [[nodiscard]] const std::vector<Node>& GetCode() const {
        return code;
    }

@@ -496,9 +498,9 @@ private:
 /// A general purpose register
 class GprNode final {
 public:
-    explicit constexpr GprNode(Tegra::Shader::Register index) : index{index} {}
+    explicit constexpr GprNode(Tegra::Shader::Register index_) : index{index_} {}

-    u32 GetIndex() const {
+    [[nodiscard]] constexpr u32 GetIndex() const {
        return static_cast<u32>(index);
    }

@@ -509,9 +511,9 @@ private:
 /// A custom variable
 class CustomVarNode final {
 public:
-    explicit constexpr CustomVarNode(u32 index) : index{index} {}
+    explicit constexpr CustomVarNode(u32 index_) : index{index_} {}

-    constexpr u32 GetIndex() const {
+    [[nodiscard]] constexpr u32 GetIndex() const {
        return index;
    }

@@ -522,9 +524,9 @@ private:
 /// A 32-bits value that represents an immediate value
 class ImmediateNode final {
 public:
-    explicit constexpr ImmediateNode(u32 value) : value{value} {}
+    explicit constexpr ImmediateNode(u32 value_) : value{value_} {}

-    u32 GetValue() const {
+    [[nodiscard]] constexpr u32 GetValue() const {
        return value;
    }

@@ -535,9 +537,9 @@ private:
 /// One of Maxwell's internal flags
 class InternalFlagNode final {
 public:
-    explicit constexpr InternalFlagNode(InternalFlag flag) : flag{flag} {}
+    explicit constexpr InternalFlagNode(InternalFlag flag_) : flag{flag_} {}

-    InternalFlag GetFlag() const {
+    [[nodiscard]] constexpr InternalFlag GetFlag() const {
        return flag;
    }

@@ -548,14 +550,14 @@ private:
 /// A predicate register, it can be negated without additional nodes
 class PredicateNode final {
 public:
-    explicit constexpr PredicateNode(Tegra::Shader::Pred index, bool negated)
-        : index{index}, negated{negated} {}
+    explicit constexpr PredicateNode(Tegra::Shader::Pred index_, bool negated_)
+        : index{index_}, negated{negated_} {}

-    Tegra::Shader::Pred GetIndex() const {
+    [[nodiscard]] constexpr Tegra::Shader::Pred GetIndex() const {
        return index;
    }

-    bool IsNegated() const {
+    [[nodiscard]] constexpr bool IsNegated() const {
        return negated;
    }

@@ -568,30 +570,30 @@ private:
 class AbufNode final {
 public:
    // Initialize for standard attributes (index is explicit).
-    explicit AbufNode(Tegra::Shader::Attribute::Index index, u32 element, Node buffer = {})
-        : buffer{std::move(buffer)}, index{index}, element{element} {}
+    explicit AbufNode(Tegra::Shader::Attribute::Index index_, u32 element_, Node buffer_ = {})
+        : buffer{std::move(buffer_)}, index{index_}, element{element_} {}

    // Initialize for physical attributes (index is a variable value).
-    explicit AbufNode(Node physical_address, Node buffer = {})
-        : physical_address{std::move(physical_address)}, buffer{std::move(buffer)} {}
+    explicit AbufNode(Node physical_address_, Node buffer_ = {})
+        : physical_address{std::move(physical_address_)}, buffer{std::move(buffer_)} {}

-    Tegra::Shader::Attribute::Index GetIndex() const {
+    [[nodiscard]] Tegra::Shader::Attribute::Index GetIndex() const {
        return index;
    }

-    u32 GetElement() const {
+    [[nodiscard]] u32 GetElement() const {
        return element;
    }

-    const Node& GetBuffer() const {
+    [[nodiscard]] const Node& GetBuffer() const {
        return buffer;
    }

-    bool IsPhysicalBuffer() const {
+    [[nodiscard]] bool IsPhysicalBuffer() const {
        return static_cast<bool>(physical_address);
    }

-    const Node& GetPhysicalAddress() const {
+    [[nodiscard]] const Node& GetPhysicalAddress() const {
        return physical_address;
    }

@@ -605,9 +607,9 @@ private:
 /// Patch memory (used to communicate tessellation stages).
 class PatchNode final {
 public:
-    explicit PatchNode(u32 offset) : offset{offset} {}
+    explicit constexpr PatchNode(u32 offset_) : offset{offset_} {}

-    u32 GetOffset() const {
+    [[nodiscard]] constexpr u32 GetOffset() const {
        return offset;
    }

@@ -618,13 +620,13 @@ private:
 /// Constant buffer node, usually mapped to uniform buffers in GLSL
 class CbufNode final {
 public:
-    explicit CbufNode(u32 index, Node offset) : index{index}, offset{std::move(offset)} {}
+    explicit CbufNode(u32 index_, Node offset_) : index{index_}, offset{std::move(offset_)} {}

-    u32 GetIndex() const {
+    [[nodiscard]] u32 GetIndex() const {
        return index;
    }

-    const Node& GetOffset() const {
+    [[nodiscard]] const Node& GetOffset() const {
        return offset;
    }

@@ -636,9 +638,9 @@ private:
 /// Local memory node
 class LmemNode final {
 public:
-    explicit LmemNode(Node address) : address{std::move(address)} {}
+    explicit LmemNode(Node address_) : address{std::move(address_)} {}

-    const Node& GetAddress() const {
+    [[nodiscard]] const Node& GetAddress() const {
        return address;
    }

@@ -649,9 +651,9 @@ private:
 /// Shared memory node
 class SmemNode final {
 public:
-    explicit SmemNode(Node address) : address{std::move(address)} {}
+    explicit SmemNode(Node address_) : address{std::move(address_)} {}

-    const Node& GetAddress() const {
+    [[nodiscard]] const Node& GetAddress() const {
        return address;
    }

@@ -662,19 +664,19 @@ private:
 /// Global memory node
 class GmemNode final {
 public:
-    explicit GmemNode(Node real_address, Node base_address, const GlobalMemoryBase& descriptor)
-        : real_address{std::move(real_address)}, base_address{std::move(base_address)},
-          descriptor{descriptor} {}
+    explicit GmemNode(Node real_address_, Node base_address_, const GlobalMemoryBase& descriptor_)
+        : real_address{std::move(real_address_)}, base_address{std::move(base_address_)},
+          descriptor{descriptor_} {}

-    const Node& GetRealAddress() const {
+    [[nodiscard]] const Node& GetRealAddress() const {
        return real_address;
    }

-    const Node& GetBaseAddress() const {
+    [[nodiscard]] const Node& GetBaseAddress() const {
        return base_address;
    }

-    const GlobalMemoryBase& GetDescriptor() const {
+    [[nodiscard]] const GlobalMemoryBase& GetDescriptor() const {
        return descriptor;
    }

@@ -687,9 +689,9 @@ private:
 /// Commentary, can be dropped
 class CommentNode final {
 public:
-    explicit CommentNode(std::string text) : text{std::move(text)} {}
+    explicit CommentNode(std::string text_) : text{std::move(text_)} {}

-    const std::string& GetText() const {
+    [[nodiscard]] const std::string& GetText() const {
        return text;
    }

@@ -167,27 +167,28 @@ std::vector<CopyParams> SurfaceBaseImpl::BreakDownNonLayered(const SurfaceParams
    return result;
 }

-void SurfaceBaseImpl::SwizzleFunc(MortonSwizzleMode mode, u8* memory, const SurfaceParams& params,
-                                  u8* buffer, u32 level) {
-    const u32 width{params.GetMipWidth(level)};
-    const u32 height{params.GetMipHeight(level)};
-    const u32 block_height{params.GetMipBlockHeight(level)};
-    const u32 block_depth{params.GetMipBlockDepth(level)};
+void SurfaceBaseImpl::SwizzleFunc(MortonSwizzleMode mode, u8* memory,
+                                  const SurfaceParams& surface_params, u8* buffer, u32 level) {
+    const u32 width{surface_params.GetMipWidth(level)};
+    const u32 height{surface_params.GetMipHeight(level)};
+    const u32 block_height{surface_params.GetMipBlockHeight(level)};
+    const u32 block_depth{surface_params.GetMipBlockDepth(level)};

    std::size_t guest_offset{mipmap_offsets[level]};
-    if (params.is_layered) {
+    if (surface_params.is_layered) {
        std::size_t host_offset = 0;
        const std::size_t guest_stride = layer_size;
-        const std::size_t host_stride = params.GetHostLayerSize(level);
-        for (u32 layer = 0; layer < params.depth; ++layer) {
-            MortonSwizzle(mode, params.pixel_format, width, block_height, height, block_depth, 1,
-                          params.tile_width_spacing, buffer + host_offset, memory + guest_offset);
+        const std::size_t host_stride = surface_params.GetHostLayerSize(level);
+        for (u32 layer = 0; layer < surface_params.depth; ++layer) {
+            MortonSwizzle(mode, surface_params.pixel_format, width, block_height, height,
+                          block_depth, 1, surface_params.tile_width_spacing, buffer + host_offset,
+                          memory + guest_offset);
            guest_offset += guest_stride;
            host_offset += host_stride;
        }
    } else {
-        MortonSwizzle(mode, params.pixel_format, width, block_height, height, block_depth,
-                      params.GetMipDepth(level), params.tile_width_spacing, buffer,
+        MortonSwizzle(mode, surface_params.pixel_format, width, block_height, height, block_depth,
+                      surface_params.GetMipDepth(level), surface_params.tile_width_spacing, buffer,
                      memory + guest_offset);
    }
 }
@@ -167,8 +167,8 @@ protected:
    std::vector<std::size_t> mipmap_offsets;

 private:
-    void SwizzleFunc(MortonSwizzleMode mode, u8* memory, const SurfaceParams& params, u8* buffer,
-                     u32 level);
+    void SwizzleFunc(MortonSwizzleMode mode, u8* memory, const SurfaceParams& surface_params,
+                     u8* buffer, u32 level);

    std::vector<CopyParams> BreakDownLayered(const SurfaceParams& in_params) const;

@@ -356,18 +356,18 @@ std::size_t SurfaceParams::GetLayerSize(bool as_host_size, bool uncompressed) co

 std::size_t SurfaceParams::GetInnerMipmapMemorySize(u32 level, bool as_host_size,
                                                    bool uncompressed) const {
-    const u32 width{GetMipmapSize(uncompressed, GetMipWidth(level), GetDefaultBlockWidth())};
-    const u32 height{GetMipmapSize(uncompressed, GetMipHeight(level), GetDefaultBlockHeight())};
-    const u32 depth{is_layered ? 1U : GetMipDepth(level)};
+    const u32 mip_width{GetMipmapSize(uncompressed, GetMipWidth(level), GetDefaultBlockWidth())};
+    const u32 mip_height{GetMipmapSize(uncompressed, GetMipHeight(level), GetDefaultBlockHeight())};
+    const u32 mip_depth{is_layered ? 1U : GetMipDepth(level)};
    if (is_tiled) {
-        return Tegra::Texture::CalculateSize(!as_host_size, GetBytesPerPixel(), width, height,
-                                             depth, GetMipBlockHeight(level),
+        return Tegra::Texture::CalculateSize(!as_host_size, GetBytesPerPixel(), mip_width,
+                                             mip_height, mip_depth, GetMipBlockHeight(level),
                                             GetMipBlockDepth(level));
    } else if (as_host_size || IsBuffer()) {
-        return GetBytesPerPixel() * width * height * depth;
+        return GetBytesPerPixel() * mip_width * mip_height * mip_depth;
    } else {
        // Linear Texture Case
-        return pitch * height * depth;
+        return pitch * mip_height * mip_depth;
    }
 }

@@ -174,7 +174,8 @@ public:
    }

    bool operator<(const QStandardItem& other) const override {
-        return data(CompatNumberRole) < other.data(CompatNumberRole);
+        return data(CompatNumberRole).value<QString>() <
+               other.data(CompatNumberRole).value<QString>();
    }
 };

@@ -345,7 +345,6 @@ void Config::ReadValues() {
    // System
    Settings::values.use_docked_mode.SetValue(
        sdl2_config->GetBoolean("System", "use_docked_mode", false));
-    const auto size = sdl2_config->GetInteger("System", "users_size", 0);

    Settings::values.current_user = std::clamp<int>(
        sdl2_config->GetInteger("System", "current_user", 0), 0, Service::Account::MAX_USERS - 1);
Author	SHA1	Message	Date
comex	feac654ba0	core: Mark unused fields as [[maybe_unused]]	2020-12-06 18:36:10 -05:00
Rodrigo Locatti	7e5f595b31	Merge pull request #5143 from comex/xx-users-size yuzu_cmd: Remove 'users_size'	2020-12-06 19:34:53 -03:00
Rodrigo Locatti	88959b0047	Merge pull request #5141 from comex/xx-true-false maxwell_dma: Rename RenderEnable::Mode::FALSE and TRUE to avoid name conflict	2020-12-06 19:34:24 -03:00
bunnei	dd05c7ec79	Merge pull request #5140 from FearlessTobi/port-5577 Port citra-emu/citra#5577: "Update cubeb and request a persistent stream session"	2020-12-06 01:53:02 -08:00
bunnei	53a04d6b5d	Merge pull request #5132 from lioncash/xbyak-abi xbyak_abi: Avoid implicit sign conversions	2020-12-06 01:22:43 -08:00
bunnei	c67c25db05	Merge pull request #5139 from lioncash/deprecated-qt game_list_p: Resolve deprecated usage of QVariant operator<	2020-12-06 00:45:23 -08:00
comex	a6e6cd5788	maxwell_dma: Rename RenderEnable::Mode::FALSE and TRUE to avoid name conflict On Apple platforms, FALSE and TRUE are defined as macros by <mach/boolean.h>, which is included by various system headers. Note that there appear to be no actual users of the names to fix up.	2020-12-05 17:59:02 -05:00
comex	9dc69fa07c	yuzu_cmd: Remove 'users_size' Specifically: const auto size = sdl2_config->GetInteger("System", "users_size", 0); The variable is never used, producing a warning. I wondered if this ought to be assigning something to in `Settings`, but nothing else in the codebase ever mentions a setting called "users_size", so I guess it's safe to remove...	2020-12-05 17:50:39 -05:00
Vitor Kiguchi	a1e7360273	Update cubeb and request a persistent stream session	2020-12-05 22:26:41 +01:00
Lioncash	c277d7d171	game_list_p: Resolve deprecated usage of QVariant operator< This is designated as obsolete in Qt's docs (see: https://doc.qt.io/qt-5/qvariant-obsolete.html#operator-lt)	2020-12-05 15:38:58 -05:00
Chloe	f2f346e110	Merge pull request #5133 from lioncash/video-shadow2 video_core: Resolve more variable shadowing scenarios pt.2	2020-12-05 23:45:00 +11:00
Lioncash	414a87a4f4	video_core: Resolve more variable shadowing scenarios pt.2 Migrates the video core code closer to enabling variable shadowing warnings as errors. This primarily sorts out shadowing occurrences within the Vulkan code.	2020-12-05 06:39:35 -05:00
bunnei	e6a896c4bd	Merge pull request #5124 from lioncash/video-shadow video_core: Resolve more variable shadowing scenarios	2020-12-05 00:48:08 -08:00
bunnei	63419e144f	Merge pull request #5127 from FearlessTobi/port-5617 Port citra-emu/citra#5617: "Fix telemetry-related exit crash from use-after-free"	2020-12-04 21:57:40 -08:00
Lioncash	2c375013dd	xbyak_abi: Shorten std::size_t to size_t Makes for less reading.	2020-12-05 00:43:55 -05:00
Lioncash	b126267442	xbyak_abi: Avoid implicit sign conversions	2020-12-05 00:43:41 -05:00
LC	2a928d7492	Merge pull request #5130 from ogniK5377/sys-11.0.0 system_version: Update to 11.0.0	2020-12-05 00:36:14 -05:00
Chloe Marcec	7fbeb489d3	system_version: Update to 11.0.0	2020-12-05 16:08:03 +11:00
FearlessTobi	37d672bf08	Fix telemetry-related exit crash from use-after-free Co-Authored-By: xperia64 <xperia64@users.noreply.github.com>	2020-12-05 02:42:50 +01:00
bunnei	1c8de85045	Merge pull request #5126 from lioncash/deprecated codec: Remove deprecated usage of AVCodecContext::refcounted_frames	2020-12-04 17:31:53 -08:00
Lioncash	94af77aa7c	codec: Remove deprecated usage of AVCodecContext::refcounted_frames This was only necessary for use with the avcodec_decode_video2/avcoded_decode_audio4 APIs which are also deprecated. Given we use avcodec_send_packet/avcodec_receive_frame, this isn't necessary, this is even indicated directly within the FFmpeg API changes document here on 2017-09-26: https://github.com/FFmpeg/FFmpeg/blob/master/doc/APIchanges#L410 This prevents our code from breaking whenever we update to a newer version of FFmpeg in the future if they ever decide to fully remove this API member.	2020-12-04 16:23:13 -05:00
Lioncash	677a8b208d	video_core: Resolve more variable shadowing scenarios Resolves variable shadowing scenarios up to the end of the OpenGL code to make it nicer to review. The rest will be resolved in a following commit.	2020-12-04 16:19:09 -05:00
bunnei	fad38ec6e8	Merge pull request #5064 from lioncash/node-shadow node: Eliminate variable shadowing	2020-12-04 00:45:33 -08:00
bunnei	defa826c53	Merge pull request #5061 from lioncash/pessimizing vp9/vic: Resolve pessimizing moves	2020-12-03 23:21:12 -08:00
Lioncash	edd8208779	node: Mark member functions as [[nodiscard]] where applicable Prevents logic bugs from accidentally ignoring the return value.	2020-12-03 16:03:34 -05:00
Lioncash	7cf34c3637	node: Eliminate variable shadowing	2020-12-03 15:59:38 -05:00
Lioncash	cf9767c608	vp9/vic: Resolve pessimizing moves Removes the usage of moves that don't result in behavior different from a copy, or otherwise would prevent copy elision from occurring.	2020-12-03 12:33:07 -05:00