correct clang-format

when docked mode is enable

src/common/CMakeLists.txt

@@ -44,6 +44,7 @@ add_library(common STATIC
     detached_tasks.cpp
     detached_tasks.h
     bit_field.h
+    bit_set.h
     cityhash.cpp
     cityhash.h
     color.h

src/common/bit_set.h

@@ -0,0 +1,244 @@
+// This file is under the public domain.
+
+#pragma once
+
+#include <cstddef>
+#ifdef _WIN32
+#include <intrin.h>
+#endif
+#include <initializer_list>
+#include <new>
+#include <type_traits>
+#include "common/common_types.h"
+
+// namespace avoids conflict with OS X Carbon; don't use BitSet<T> directly
+namespace Common {
+
+// Helper functions:
+
+#ifdef _MSC_VER
+template <typename T>
+static inline int CountSetBits(T v) {
+    // from https://graphics.stanford.edu/~seander/bithacks.html
+    // GCC has this built in, but MSVC's intrinsic will only emit the actual
+    // POPCNT instruction, which we're not depending on
+    v = v - ((v >> 1) & (T) ~(T)0 / 3);
+    v = (v & (T) ~(T)0 / 15 * 3) + ((v >> 2) & (T) ~(T)0 / 15 * 3);
+    v = (v + (v >> 4)) & (T) ~(T)0 / 255 * 15;
+    return (T)(v * ((T) ~(T)0 / 255)) >> (sizeof(T) - 1) * 8;
+}
+static inline int LeastSignificantSetBit(u8 val) {
+    unsigned long index;
+    _BitScanForward(&index, val);
+    return (int)index;
+}
+static inline int LeastSignificantSetBit(u16 val) {
+    unsigned long index;
+    _BitScanForward(&index, val);
+    return (int)index;
+}
+static inline int LeastSignificantSetBit(u32 val) {
+    unsigned long index;
+    _BitScanForward(&index, val);
+    return (int)index;
+}
+static inline int LeastSignificantSetBit(u64 val) {
+    unsigned long index;
+    _BitScanForward64(&index, val);
+    return (int)index;
+}
+#else
+static inline int CountSetBits(u8 val) {
+    return __builtin_popcount(val);
+}
+static inline int CountSetBits(u16 val) {
+    return __builtin_popcount(val);
+}
+static inline int CountSetBits(u32 val) {
+    return __builtin_popcount(val);
+}
+static inline int CountSetBits(u64 val) {
+    return __builtin_popcountll(val);
+}
+static inline int LeastSignificantSetBit(u8 val) {
+    return __builtin_ctz(val);
+}
+static inline int LeastSignificantSetBit(u16 val) {
+    return __builtin_ctz(val);
+}
+static inline int LeastSignificantSetBit(u32 val) {
+    return __builtin_ctz(val);
+}
+static inline int LeastSignificantSetBit(u64 val) {
+    return __builtin_ctzll(val);
+}
+#endif
+
+// Similar to std::bitset, this is a class which encapsulates a bitset, i.e.
+// using the set bits of an integer to represent a set of integers.  Like that
+// class, it acts like an array of bools:
+//     BitSet32 bs;
+//     bs[1] = true;
+// but also like the underlying integer ([0] = least significant bit):
+//     BitSet32 bs2 = ...;
+//     bs = (bs ^ bs2) & BitSet32(0xffff);
+// The following additional functionality is provided:
+// - Construction using an initializer list.
+//     BitSet bs { 1, 2, 4, 8 };
+// - Efficiently iterating through the set bits:
+//     for (int i : bs)
+//         [i is the *index* of a set bit]
+//   (This uses the appropriate CPU instruction to find the next set bit in one
+//   operation.)
+// - Counting set bits using .Count() - see comment on that method.
+
+// TODO: use constexpr when MSVC gets out of the Dark Ages
+
+template <typename IntTy>
+class BitSet {
+    static_assert(!std::is_signed_v<IntTy>, "BitSet should not be used with signed types");
+
+public:
+    // A reference to a particular bit, returned from operator[].
+    class Ref {
+    public:
+        Ref(Ref&& other) : m_bs(other.m_bs), m_mask(other.m_mask) {}
+        Ref(BitSet* bs, IntTy mask) : m_bs(bs), m_mask(mask) {}
+        operator bool() const {
+            return (m_bs->m_val & m_mask) != 0;
+        }
+        bool operator=(bool set) {
+            m_bs->m_val = (m_bs->m_val & ~m_mask) | (set ? m_mask : 0);
+            return set;
+        }
+
+    private:
+        BitSet* m_bs;
+        IntTy m_mask;
+    };
+
+    // A STL-like iterator is required to be able to use range-based for loops.
+    class Iterator {
+    public:
+        Iterator(const Iterator& other) : m_val(other.m_val), m_bit(other.m_bit) {}
+        Iterator(IntTy val) : m_val(val), m_bit(0) {}
+        Iterator& operator=(Iterator other) {
+            new (this) Iterator(other);
+            return *this;
+        }
+        int operator*() {
+            return m_bit + ComputeLsb();
+        }
+        Iterator& operator++() {
+            int lsb = ComputeLsb();
+            m_val >>= lsb + 1;
+            m_bit += lsb + 1;
+            m_has_lsb = false;
+            return *this;
+        }
+        Iterator operator++(int _) {
+            Iterator other(*this);
+            ++*this;
+            return other;
+        }
+        bool operator==(Iterator other) const {
+            return m_val == other.m_val;
+        }
+        bool operator!=(Iterator other) const {
+            return m_val != other.m_val;
+        }
+
+    private:
+        int ComputeLsb() {
+            if (!m_has_lsb) {
+                m_lsb = LeastSignificantSetBit(m_val);
+                m_has_lsb = true;
+            }
+            return m_lsb;
+        }
+        IntTy m_val;
+        int m_bit;
+        int m_lsb = -1;
+        bool m_has_lsb = false;
+    };
+
+    BitSet() : m_val(0) {}
+    explicit BitSet(IntTy val) : m_val(val) {}
+    BitSet(std::initializer_list<int> init) {
+        m_val = 0;
+        for (int bit : init)
+            m_val |= (IntTy)1 << bit;
+    }
+
+    static BitSet AllTrue(std::size_t count) {
+        return BitSet(count == sizeof(IntTy) * 8 ? ~(IntTy)0 : (((IntTy)1 << count) - 1));
+    }
+
+    Ref operator[](std::size_t bit) {
+        return Ref(this, (IntTy)1 << bit);
+    }
+    const Ref operator[](std::size_t bit) const {
+        return (*const_cast<BitSet*>(this))[bit];
+    }
+    bool operator==(BitSet other) const {
+        return m_val == other.m_val;
+    }
+    bool operator!=(BitSet other) const {
+        return m_val != other.m_val;
+    }
+    bool operator<(BitSet other) const {
+        return m_val < other.m_val;
+    }
+    bool operator>(BitSet other) const {
+        return m_val > other.m_val;
+    }
+    BitSet operator|(BitSet other) const {
+        return BitSet(m_val | other.m_val);
+    }
+    BitSet operator&(BitSet other) const {
+        return BitSet(m_val & other.m_val);
+    }
+    BitSet operator^(BitSet other) const {
+        return BitSet(m_val ^ other.m_val);
+    }
+    BitSet operator~() const {
+        return BitSet(~m_val);
+    }
+    BitSet& operator|=(BitSet other) {
+        return *this = *this | other;
+    }
+    BitSet& operator&=(BitSet other) {
+        return *this = *this & other;
+    }
+    BitSet& operator^=(BitSet other) {
+        return *this = *this ^ other;
+    }
+    operator u32() = delete;
+    operator bool() {
+        return m_val != 0;
+    }
+
+    // Warning: Even though on modern CPUs this is a single fast instruction,
+    // Dolphin's official builds do not currently assume POPCNT support on x86,
+    // so slower explicit bit twiddling is generated.  Still should generally
+    // be faster than a loop.
+    unsigned int Count() const {
+        return CountSetBits(m_val);
+    }
+
+    Iterator begin() const {
+        return Iterator(m_val);
+    }
+    Iterator end() const {
+        return Iterator(0);
+    }
+
+    IntTy m_val;
+};
+
+} // namespace Common
+
+typedef Common::BitSet<u8> BitSet8;
+typedef Common::BitSet<u16> BitSet16;
+typedef Common::BitSet<u32> BitSet32;
+typedef Common::BitSet<u64> BitSet64;

src/core/hle/kernel/handle_table.cpp

@@ -12,23 +12,12 @@
 #include "core/hle/kernel/thread.h"
 
 namespace Kernel {
-namespace {
-constexpr u16 GetSlot(Handle handle) {
-    return handle >> 15;
-}
-
-constexpr u16 GetGeneration(Handle handle) {
-    return handle & 0x7FFF;
-}
-} // Anonymous namespace
 
 HandleTable::HandleTable() {
     next_generation = 1;
     Clear();
 }
 
-HandleTable::~HandleTable() = default;
-
 ResultVal<Handle> HandleTable::Create(SharedPtr<Object> obj) {
     DEBUG_ASSERT(obj != nullptr);
 

src/core/hle/kernel/handle_table.h

@@ -43,7 +43,6 @@ enum KernelHandle : Handle {
 class HandleTable final : NonCopyable {
 public:
     HandleTable();
-    ~HandleTable();
 
     /**
      * Allocates a handle for the given object.
@@ -90,8 +89,18 @@ public:
     void Clear();
 
 private:
-    /// This is the maximum limit of handles allowed per process in Horizon
-    static constexpr std::size_t MAX_COUNT = 1024;
+    /**
+     * This is the maximum limit of handles allowed per process in CTR-OS. It can be further
+     * reduced by ExHeader values, but this is not emulated here.
+     */
+    static const std::size_t MAX_COUNT = 4096;
+
+    static u16 GetSlot(Handle handle) {
+        return handle >> 15;
+    }
+    static u16 GetGeneration(Handle handle) {
+        return handle & 0x7FFF;
+    }
 
     /// Stores the Object referenced by the handle or null if the slot is empty.
     std::array<SharedPtr<Object>, MAX_COUNT> objects;

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

@@ -44,10 +44,8 @@ enum class AudioState : u32 {
 
 class IAudioOut final : public ServiceFramework<IAudioOut> {
 public:
-    IAudioOut(AudoutParams audio_params, AudioCore::AudioOut& audio_core, std::string&& device_name,
-              std::string&& unique_name)
-        : ServiceFramework("IAudioOut"), audio_core(audio_core), audio_params(audio_params),
-          device_name(std::move(device_name)) {
+    IAudioOut(AudoutParams audio_params, AudioCore::AudioOut& audio_core)
+        : ServiceFramework("IAudioOut"), audio_core(audio_core), audio_params(audio_params) {
 
         static const FunctionInfo functions[] = {
             {0, &IAudioOut::GetAudioOutState, "GetAudioOutState"},
@@ -71,7 +69,7 @@ public:
             Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, "IAudioOutBufferReleased");
 
         stream = audio_core.OpenStream(audio_params.sample_rate, audio_params.channel_count,
-                                       std::move(unique_name), [=]() { buffer_event->Signal(); });
+                                       "IAudioOut", [=]() { buffer_event->Signal(); });
     }
 
 private:
@@ -179,7 +177,6 @@ private:
 
     AudioCore::AudioOut& audio_core;
     AudioCore::StreamPtr stream;
-    std::string device_name;
 
     AudoutParams audio_params{};
 
@@ -202,15 +199,7 @@ void AudOutU::ListAudioOutsImpl(Kernel::HLERequestContext& ctx) {
 void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_Audio, "called");
 
-    const auto device_name_data{ctx.ReadBuffer()};
-    std::string device_name;
-    if (device_name_data[0] != '\0') {
-        device_name.assign(device_name_data.begin(), device_name_data.end());
-    } else {
-        device_name.assign(DefaultDevice.begin(), DefaultDevice.end());
-    }
-    ctx.WriteBuffer(device_name);
-
+    ctx.WriteBuffer(DefaultDevice);
     IPC::RequestParser rp{ctx};
     auto params{rp.PopRaw<AudoutParams>()};
     if (params.channel_count <= 2) {
@@ -223,9 +212,10 @@ void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
         params.sample_rate = DefaultSampleRate;
     }
 
-    std::string unique_name{fmt::format("{}-{}", device_name, audio_out_interfaces.size())};
-    auto audio_out_interface = std::make_shared<IAudioOut>(
-        params, *audio_core, std::move(device_name), std::move(unique_name));
+    // TODO(bunnei): Support more than one IAudioOut interface. When we add this, ListAudioOutsImpl
+    // will likely need to be updated as well.
+    ASSERT_MSG(!audio_out_interface, "Unimplemented");
+    audio_out_interface = std::make_shared<IAudioOut>(params, *audio_core);
 
     IPC::ResponseBuilder rb{ctx, 6, 0, 1};
     rb.Push(RESULT_SUCCESS);
@@ -234,8 +224,6 @@ void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
     rb.Push<u32>(static_cast<u32>(AudioCore::Codec::PcmFormat::Int16));
     rb.Push<u32>(static_cast<u32>(AudioState::Stopped));
     rb.PushIpcInterface<Audio::IAudioOut>(audio_out_interface);
-
-    audio_out_interfaces.push_back(std::move(audio_out_interface));
 }
 
 AudOutU::AudOutU() : ServiceFramework("audout:u") {

src/core/hle/service/audio/audout_u.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <vector>
 #include "core/hle/service/service.h"
 
 namespace AudioCore {
@@ -25,7 +24,7 @@ public:
     ~AudOutU() override;
 
 private:
-    std::vector<std::shared_ptr<IAudioOut>> audio_out_interfaces;
+    std::shared_ptr<IAudioOut> audio_out_interface;
     std::unique_ptr<AudioCore::AudioOut> audio_core;
 
     void ListAudioOutsImpl(Kernel::HLERequestContext& ctx);

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

@@ -71,9 +71,8 @@ void Controller_DebugPad::OnUpdate(u8* data, std::size_t size) {
 
 void Controller_DebugPad::OnLoadInputDevices() {
     std::transform(Settings::values.debug_pad_buttons.begin(),
-                   Settings::values.debug_pad_buttons.begin() +
-                       Settings::NativeButton::NUM_BUTTONS_HID,
-                   buttons.begin(), Input::CreateDevice<Input::ButtonDevice>);
+                   Settings::values.debug_pad_buttons.end(), buttons.begin(),
+                   Input::CreateDevice<Input::ButtonDevice>);
     std::transform(Settings::values.debug_pad_analogs.begin(),
                    Settings::values.debug_pad_analogs.end(), analogs.begin(),
                    Input::CreateDevice<Input::AnalogDevice>);

src/video_core/engines/maxwell_3d.h

@@ -389,13 +389,6 @@ public:
                 ReverseSubtract = 3,
                 Min = 4,
                 Max = 5,
-
-                // These values are used by Nouveau and some games.
-                AddGL = 0x8006,
-                SubtractGL = 0x8007,
-                ReverseSubtractGL = 0x8008,
-                MinGL = 0x800a,
-                MaxGL = 0x800b
             };
 
             enum class Factor : u32 {

src/video_core/macro_interpreter.cpp

@@ -35,7 +35,6 @@ void MacroInterpreter::Reset() {
     // The next parameter index starts at 1, because $r1 already has the value of the first
     // parameter.
     next_parameter_index = 1;
-    carry_flag = false;
 }
 
 bool MacroInterpreter::Step(u32 offset, bool is_delay_slot) {
@@ -136,28 +135,14 @@ MacroInterpreter::Opcode MacroInterpreter::GetOpcode(u32 offset) const {
     return {macro_memory[offset + pc / sizeof(u32)]};
 }
 
-u32 MacroInterpreter::GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) {
+u32 MacroInterpreter::GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) const {
     switch (operation) {
-    case ALUOperation::Add: {
-        const u64 result{static_cast<u64>(src_a) + src_b};
-        carry_flag = result > 0xffffffff;
-        return static_cast<u32>(result);
-    }
-    case ALUOperation::AddWithCarry: {
-        const u64 result{static_cast<u64>(src_a) + src_b + (carry_flag ? 1ULL : 0ULL)};
-        carry_flag = result > 0xffffffff;
-        return static_cast<u32>(result);
-    }
-    case ALUOperation::Subtract: {
-        const u64 result{static_cast<u64>(src_a) - src_b};
-        carry_flag = result < 0x100000000;
-        return static_cast<u32>(result);
-    }
-    case ALUOperation::SubtractWithBorrow: {
-        const u64 result{static_cast<u64>(src_a) - src_b - (carry_flag ? 0ULL : 1ULL)};
-        carry_flag = result < 0x100000000;
-        return static_cast<u32>(result);
-    }
+    case ALUOperation::Add:
+        return src_a + src_b;
+    // TODO(Subv): Implement AddWithCarry
+    case ALUOperation::Subtract:
+        return src_a - src_b;
+    // TODO(Subv): Implement SubtractWithBorrow
     case ALUOperation::Xor:
         return src_a ^ src_b;
     case ALUOperation::Or:

src/video_core/macro_interpreter.h

@@ -117,7 +117,7 @@ private:
     bool Step(u32 offset, bool is_delay_slot);
 
     /// Calculates the result of an ALU operation. src_a OP src_b;
-    u32 GetALUResult(ALUOperation operation, u32 src_a, u32 src_b);
+    u32 GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) const;
 
     /// Performs the result operation on the input result and stores it in the specified register
     /// (if necessary).
@@ -165,7 +165,5 @@ private:
     std::vector<u32> parameters;
     /// Index of the next parameter that will be fetched by the 'parm' instruction.
     u32 next_parameter_index = 0;
-
-    bool carry_flag{};
 };
 } // namespace Tegra

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -1275,31 +1275,6 @@ Surface RasterizerCacheOpenGL::GetUncachedSurface(const SurfaceParams& params) {
     return surface;
 }
 
-void RasterizerCacheOpenGL::FastLayeredCopySurface(const Surface& src_surface,
-                                                   const Surface& dst_surface) {
-    const auto& init_params{src_surface->GetSurfaceParams()};
-    const auto& dst_params{dst_surface->GetSurfaceParams()};
-    VAddr address = init_params.addr;
-    const std::size_t layer_size = dst_params.LayerMemorySize();
-    for (u32 layer = 0; layer < dst_params.depth; layer++) {
-        for (u32 mipmap = 0; mipmap < dst_params.max_mip_level; mipmap++) {
-            const VAddr sub_address = address + dst_params.GetMipmapLevelOffset(mipmap);
-            const Surface& copy = TryGet(sub_address);
-            if (!copy)
-                continue;
-            const auto& src_params{copy->GetSurfaceParams()};
-            const u32 width{std::min(src_params.width, dst_params.MipWidth(mipmap))};
-            const u32 height{std::min(src_params.height, dst_params.MipHeight(mipmap))};
-
-            glCopyImageSubData(copy->Texture().handle, SurfaceTargetToGL(src_params.target), 0, 0,
-                               0, 0, dst_surface->Texture().handle,
-                               SurfaceTargetToGL(dst_params.target), mipmap, 0, 0, layer, width,
-                               height, 1);
-        }
-        address += layer_size;
-    }
-}
-
 void RasterizerCacheOpenGL::FermiCopySurface(
     const Tegra::Engines::Fermi2D::Regs::Surface& src_config,
     const Tegra::Engines::Fermi2D::Regs::Surface& dst_config) {
@@ -1365,13 +1340,11 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
             CopySurface(old_surface, new_surface, copy_pbo.handle);
         }
         break;
-    case SurfaceTarget::Texture3D:
-        AccurateCopySurface(old_surface, new_surface);
-        break;
     case SurfaceTarget::TextureCubemap:
+    case SurfaceTarget::Texture3D:
     case SurfaceTarget::Texture2DArray:
     case SurfaceTarget::TextureCubeArray:
-        FastLayeredCopySurface(old_surface, new_surface);
+        AccurateCopySurface(old_surface, new_surface);
         break;
     default:
         LOG_CRITICAL(Render_OpenGL, "Unimplemented surface target={}",

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -350,7 +350,6 @@ private:
 
     /// Performs a slow but accurate surface copy, flushing to RAM and reinterpreting the data
     void AccurateCopySurface(const Surface& src_surface, const Surface& dst_surface);
-    void FastLayeredCopySurface(const Surface& src_surface, const Surface& dst_surface);
 
     /// The surface reserve is a "backup" cache, this is where we put unique surfaces that have
     /// previously been used. This is to prevent surfaces from being constantly created and

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -218,19 +218,14 @@ inline GLenum DepthCompareFunc(Tegra::Texture::DepthCompareFunc func) {
 inline GLenum BlendEquation(Maxwell::Blend::Equation equation) {
     switch (equation) {
     case Maxwell::Blend::Equation::Add:
-    case Maxwell::Blend::Equation::AddGL:
         return GL_FUNC_ADD;
     case Maxwell::Blend::Equation::Subtract:
-    case Maxwell::Blend::Equation::SubtractGL:
         return GL_FUNC_SUBTRACT;
     case Maxwell::Blend::Equation::ReverseSubtract:
-    case Maxwell::Blend::Equation::ReverseSubtractGL:
         return GL_FUNC_REVERSE_SUBTRACT;
     case Maxwell::Blend::Equation::Min:
-    case Maxwell::Blend::Equation::MinGL:
         return GL_MIN;
     case Maxwell::Blend::Equation::Max:
-    case Maxwell::Blend::Equation::MaxGL:
         return GL_MAX;
     }
     LOG_ERROR(Render_OpenGL, "Unimplemented blend equation={}", static_cast<u32>(equation));

src/yuzu/configuration/configure_input.cpp

@@ -93,6 +93,10 @@ void ConfigureInput::CallConfigureDialog(Args&&... args) {
 }
 
 void ConfigureInput::OnDockedModeChanged(bool last_state, bool new_state) {
+    if (ui->use_docked_mode->isChecked() && ui->handheld_connected->isChecked()){
+        ui->handheld_connected->setChecked(false);
+    }
+
     if (last_state == new_state) {
         return;
     }