+We happily accept monetary donations, or donated games and hardware. Please see our [donations page](https://yuzu-emu.org/donate/) for more information on how you can contribute to yuzu. Any donations received will go towards things like:

+ const auto buffer_release_ns = GetBufferReleaseNS(*active_buffer);

+

+ // If ns_late is higher than the update rate ignore the delay

+ if (ns_late > buffer_release_ns) {

+ ns_late = {};

+ }

+

+ core_timing.ScheduleEvent(buffer_release_ns - ns_late, release_event, {});

+template <typename T, std::size_t capacity>

+ /// A "slot" is made of a single `T`.

+ static constexpr std::size_t slot_size = sizeof(T);

+ static_assert(capacity < std::numeric_limits<std::size_t>::max() / 2);

+ std::memcpy(m_data.data() + pos, in, first_copy * slot_size);

+ std::memcpy(out, m_data.data() + pos, first_copy * slot_size);

+ std::vector<T> out(std::min(max_slots, capacity));

+ const std::size_t count = Pop(out.data(), out.size());

+ out.resize(count);

+ std::array<T, capacity> m_data;

+

+/**

+ * This macro is similar to SCOPE_EXIT, except the object is caller managed. This is intended to be

+ * used when the caller might want to cancel the ScopeExit.

+ */

+#define SCOPE_GUARD(body) detail::ScopeExit([&]() body)

+ hle/kernel/k_event.cpp

+ hle/kernel/k_event.h

+ hle/kernel/k_readable_event.cpp

+ hle/kernel/k_readable_event.h

+ hle/kernel/k_writable_event.cpp

+ hle/kernel/k_writable_event.h

+struct AnalogProperties {

+ float deadzone;

+ float range;

+ float threshold;

+};

+ virtual StatusType GetRawStatus() const {

+ return GetStatus();

+ }

+ virtual AnalogProperties GetAnalogProperties() const {

+ return {};

+ }

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+class KReadableEvent;

+class KWritableEvent;

+ if (!UpdateIfEqual(system, &user_value, addr, value, value + 1)) {

+ LOG_ERROR(Kernel, "Invalid current memory!");

+ return Svc::ResultInvalidCurrentMemory;

+ }

+ if (user_value != value) {

+ return Svc::ResultInvalidState;

+ }

+ [[maybe_unused]] const KScopedSchedulerLock sl(kernel);

+ if (count <= 0) {

+ if (it != thread_tree.end() && it->GetAddressArbiterKey() == addr) {

+ new_value = value - 2;

+ new_value = value + 1;

+ if (it != thread_tree.end() && it->GetAddressArbiterKey() == addr) {

+ while (++tmp_it != thread_tree.end() && tmp_it->GetAddressArbiterKey() == addr) {

+ if (tmp_num_waiters++ >= count) {

+ break;

+ }

+ if (tmp_num_waiters < count) {

+ } else {

+ new_value = value + 1;

+ succeeded = UpdateIfEqual(system, &user_value, addr, value, new_value);

+ succeeded = ReadFromUser(system, &user_value, addr);

+ if (!succeeded) {

+ LOG_ERROR(Kernel, "Invalid current memory!");

+ return Svc::ResultInvalidCurrentMemory;

+ }

+ if (user_value != value) {

+ return Svc::ResultInvalidState;

+ }

+ succeeded = DecrementIfLessThan(system, &user_value, addr, value);

+ succeeded = ReadFromUser(system, &user_value, addr);

+ cur_thread->SetAddressArbiter(&thread_tree, addr);

+ return cur_thread->GetWaitResult(&dummy);

+ if (!ReadFromUser(system, &user_value, addr)) {

+ cur_thread->SetAddressArbiter(&thread_tree, addr);

+ return cur_thread->GetWaitResult(&dummy);

+// Copyright 2021 yuzu emulator team

+// Licensed under GPLv2 or any later version

+// Refer to the license.txt file included.

+

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+

+namespace Kernel {

+

+KEvent::KEvent(KernelCore& kernel, std::string&& name) : Object{kernel, std::move(name)} {}

+

+KEvent::~KEvent() = default;

+

+std::shared_ptr<KEvent> KEvent::Create(KernelCore& kernel, std::string&& name) {

+ return std::make_shared<KEvent>(kernel, std::move(name));

+}

+

+void KEvent::Initialize() {

+ // Create our sub events.

+ readable_event = std::make_shared<KReadableEvent>(kernel, GetName() + ":Readable");

+ writable_event = std::make_shared<KWritableEvent>(kernel, GetName() + ":Writable");

+

+ // Initialize our sub sessions.

+ readable_event->Initialize(this);

+ writable_event->Initialize(this);

+

+ // Mark initialized.

+ initialized = true;

+}

+

+} // namespace Kernel

+// Copyright 2021 yuzu emulator team

+// Licensed under GPLv2 or any later version

+// Refer to the license.txt file included.

+

+#pragma once

+

+#include "core/hle/kernel/object.h"

+

+namespace Kernel {

+

+class KernelCore;

+class KReadableEvent;

+class KWritableEvent;

+

+class KEvent final : public Object {

+public:

+ explicit KEvent(KernelCore& kernel, std::string&& name);

+ ~KEvent() override;

+

+ static std::shared_ptr<KEvent> Create(KernelCore& kernel, std::string&& name);

+

+ void Initialize();

+

+ void Finalize() override {}

+

+ std::string GetTypeName() const override {

+ return "KEvent";

+ }

+

+ static constexpr HandleType HANDLE_TYPE = HandleType::Event;

+ HandleType GetHandleType() const override {

+ return HANDLE_TYPE;

+ }

+

+ std::shared_ptr<KReadableEvent>& GetReadableEvent() {

+ return readable_event;

+ }

+

+ std::shared_ptr<KWritableEvent>& GetWritableEvent() {

+ return writable_event;

+ }

+

+ const std::shared_ptr<KReadableEvent>& GetReadableEvent() const {

+ return readable_event;

+ }

+

+ const std::shared_ptr<KWritableEvent>& GetWritableEvent() const {

+ return writable_event;

+ }

+

+private:

+ std::shared_ptr<KReadableEvent> readable_event;

+ std::shared_ptr<KWritableEvent> writable_event;

+ bool initialized{};

+};

+

+} // namespace Kernel

+ {t.SetAffinityMask(0)};

+ { t.GetAffinity(0) }

+ {t.SetAffinity(0, false)};

+ { t.GetPriorityQueueEntry(0) }

+ { std::remove_cvref_t<decltype(t.GetAffinityMask())>() }

+template <typename Member, size_t NumCores_, int LowestPriority, int HighestPriority>

+ using AffinityMaskType = std::remove_cv_t<

+ std::remove_reference_t<decltype(std::declval<Member>().GetAffinityMask())>>;

+ static constexpr size_t NumCores = NumCores_;

+// Copyright 2021 yuzu emulator team

+// Licensed under GPLv2 or any later version

+// Refer to the license.txt file included.

+

+#include <algorithm>

+#include "common/assert.h"

+#include "common/common_funcs.h"

+#include "common/logging/log.h"

+#include "core/hle/kernel/errors.h"

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_scheduler.h"

+#include "core/hle/kernel/k_thread.h"

+#include "core/hle/kernel/kernel.h"

+#include "core/hle/kernel/object.h"

+#include "core/hle/kernel/svc_results.h"

+

+namespace Kernel {

+

+KReadableEvent::KReadableEvent(KernelCore& kernel, std::string&& name)

+ : KSynchronizationObject{kernel, std::move(name)} {}

+KReadableEvent::~KReadableEvent() = default;

+

+bool KReadableEvent::IsSignaled() const {

+ ASSERT(kernel.GlobalSchedulerContext().IsLocked());

+

+ return is_signaled;

+}

+

+ResultCode KReadableEvent::Signal() {

+ KScopedSchedulerLock lk{kernel};

+

+ if (!is_signaled) {

+ is_signaled = true;

+ NotifyAvailable();

+ }

+

+ return RESULT_SUCCESS;

+}

+

+ResultCode KReadableEvent::Clear() {

+ Reset();

+

+ return RESULT_SUCCESS;

+}

+

+ResultCode KReadableEvent::Reset() {

+ KScopedSchedulerLock lk{kernel};

+

+ if (!is_signaled) {

+ return Svc::ResultInvalidState;

+ }

+

+ is_signaled = false;

+ return RESULT_SUCCESS;

+}

+

+} // namespace Kernel

+// Copyright 2021 yuzu emulator team

+// Licensed under GPLv2 or any later version

+// Refer to the license.txt file included.

+

+#pragma once

+

+#include "core/hle/kernel/k_synchronization_object.h"

+#include "core/hle/kernel/object.h"

+#include "core/hle/result.h"

+

+namespace Kernel {

+

+class KernelCore;

+class KEvent;

+

+class KReadableEvent final : public KSynchronizationObject {

+public:

+ explicit KReadableEvent(KernelCore& kernel, std::string&& name);

+ ~KReadableEvent() override;

+

+ std::string GetTypeName() const override {

+ return "KReadableEvent";

+ }

+

+ static constexpr HandleType HANDLE_TYPE = HandleType::ReadableEvent;

+ HandleType GetHandleType() const override {

+ return HANDLE_TYPE;

+ }

+

+ KEvent* GetParent() const {

+ return parent;

+ }

+

+ void Initialize(KEvent* parent_) {

+ is_signaled = false;

+ parent = parent_;

+ }

+

+ bool IsSignaled() const override;

+ void Finalize() override {}

+

+ ResultCode Signal();

+ ResultCode Clear();

+ ResultCode Reset();

+

+private:

+ bool is_signaled{};

+ KEvent* parent{};

+};

+

+} // namespace Kernel

+KSynchronizationObject::KSynchronizationObject(KernelCore& kernel, std::string&& name)

+ : Object{kernel, std::move(name)} {}

+

+ explicit KSynchronizationObject(KernelCore& kernel, std::string&& name);

+// Copyright 2021 yuzu emulator team

+// Licensed under GPLv2 or any later version

+// Refer to the license.txt file included.

+

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+

+namespace Kernel {

+

+KWritableEvent::KWritableEvent(KernelCore& kernel, std::string&& name)

+ : Object{kernel, std::move(name)} {}

+KWritableEvent::~KWritableEvent() = default;

+

+void KWritableEvent::Initialize(KEvent* parent_) {

+ parent = parent_;

+}

+

+ResultCode KWritableEvent::Signal() {

+ return parent->GetReadableEvent()->Signal();

+}

+

+ResultCode KWritableEvent::Clear() {

+ return parent->GetReadableEvent()->Clear();

+}

+

+} // namespace Kernel

+// Copyright 2021 yuzu Emulator Project

+// Licensed under GPLv2 or any later version

+// Refer to the license.txt file included.

+

+#pragma once

+

+#include "core/hle/kernel/object.h"

+#include "core/hle/result.h"

+

+namespace Kernel {

+

+class KernelCore;

+class KEvent;

+

+class KWritableEvent final : public Object {

+public:

+ explicit KWritableEvent(KernelCore& kernel, std::string&& name);

+ ~KWritableEvent() override;

+

+ std::string GetTypeName() const override {

+ return "KWritableEvent";

+ }

+

+ static constexpr HandleType HANDLE_TYPE = HandleType::WritableEvent;

+ HandleType GetHandleType() const override {

+ return HANDLE_TYPE;

+ }

+

+ void Initialize(KEvent* parent_);

+

+ void Finalize() override {}

+

+ ResultCode Signal();

+ ResultCode Clear();

+

+ KEvent* GetParent() const {

+ return parent;

+ }

+

+private:

+ KEvent* parent{};

+};

+

+} // namespace Kernel

+Object::Object(KernelCore& kernel_)

+ : kernel{kernel_}, object_id{kernel_.CreateNewObjectID()}, name{"[UNKNOWN KERNEL OBJECT]"} {}

+Object::Object(KernelCore& kernel_, std::string&& name_)

+ : kernel{kernel_}, object_id{kernel_.CreateNewObjectID()}, name{std::move(name_)} {}

+ case HandleType::Event:

+ Event,

+ explicit Object(KernelCore& kernel_);

+ explicit Object(KernelCore& kernel_, std::string&& name_);

+ return name;

+ std::string name;

+#include "core/hle/kernel/svc_results.h"

+ResultCode Process::Reset() {

+ // Lock the process and the scheduler.

+ KScopedLightLock lk(state_lock);

+ KScopedSchedulerLock sl{kernel};

+ // Validate that we're in a state that we can reset.

+ R_UNLESS(status != ProcessStatus::Exited, Svc::ResultInvalidState);

+ R_UNLESS(is_signaled, Svc::ResultInvalidState);

+ // Clear signaled.

+ ResultCode Reset();

+#include "common/scope_exit.h"

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ if (!thread) {

+ LOG_ERROR(Kernel_SVC, "Invalid thread handle provided (handle={:08X})", thread_handle);

+ return ResultInvalidHandle;

+ }

+ if (!thread) {

+ LOG_ERROR(Kernel_SVC, "Invalid thread handle provided (handle={:08X})", thread_handle);

+ return ResultInvalidHandle;

+ }

+ if (Memory::IsKernelAddress(address)) {

+ LOG_ERROR(Kernel_SVC, "Attempting to arbitrate a lock on a kernel address (address={:08X})",

+ address);

+ return ResultInvalidCurrentMemory;

+ }

+ if (!Common::IsAligned(address, sizeof(u32))) {

+ LOG_ERROR(Kernel_SVC, "Input address must be 4 byte aligned (address: {:08X})", address);

+ return ResultInvalidAddress;

+ }

+ if (Memory::IsKernelAddress(address)) {

+ LOG_ERROR(Kernel_SVC,

+ "Attempting to arbitrate an unlock on a kernel address (address={:08X})",

+ address);

+ return ResultInvalidCurrentMemory;

+ }

+ if (!Common::IsAligned(address, sizeof(u32))) {

+ LOG_ERROR(Kernel_SVC, "Input address must be 4 byte aligned (address: {:08X})", address);

+ return ResultInvalidAddress;

+ }

+ ThreadActivity thread_activity) {

+ constexpr auto IsValidThreadActivity = [](ThreadActivity activity) {

+ return activity == ThreadActivity::Runnable || activity == ThreadActivity::Paused;

+ };

+ if (!IsValidThreadActivity(thread_activity)) {

+ LOG_ERROR(Kernel_SVC, "Invalid thread activity value provided (activity={})",

+ thread_activity);

+ return ResultInvalidEnumValue;

+ }

+ if (!thread) {

+ LOG_ERROR(Kernel_SVC, "Invalid thread handle provided (handle={:08X})", thread_handle);

+ return ResultInvalidHandle;

+ }

+ if (thread->GetOwnerProcess() != kernel.CurrentProcess()) {

+ LOG_ERROR(Kernel_SVC, "Invalid owning process for the created thread.");

+ return ResultInvalidHandle;

+ }

+ if (thread.get() == GetCurrentThreadPointer(kernel)) {

+ LOG_ERROR(Kernel_SVC, "Thread is busy");

+ return ResultBusy;

+ }

+ const auto set_result = thread->SetActivity(thread_activity);

+ if (set_result.IsError()) {

+ LOG_ERROR(Kernel_SVC, "Failed to set thread activity.");

+ return set_result;

+ }

+ if (!thread) {

+ LOG_ERROR(Kernel_SVC, "Invalid thread handle provided (handle={})", thread_handle);

+ return ResultInvalidHandle;

+ }

+ if (thread->GetOwnerProcess() != current_process) {

+ LOG_ERROR(Kernel_SVC, "Thread owning process is not the current process.");

+ return ResultInvalidHandle;

+ }

+ if (thread.get() == system.Kernel().CurrentScheduler()->GetCurrentThread()) {

+ LOG_ERROR(Kernel_SVC, "Current thread is busy.");

+ return ResultBusy;

+ }

+ const auto context_result = thread->GetThreadContext3(context);

+ if (context_result.IsError()) {

+ LOG_ERROR(Kernel_SVC, "Unable to successfully retrieve thread context (result: {})",

+ context_result.raw);

+ return context_result;

+ }

+ if (!thread) {

+ LOG_ERROR(Kernel_SVC, "Invalid thread handle provided (handle={:08X})", handle);

+ return ResultInvalidHandle;

+ }

+ if (HighestThreadPriority > priority || priority > LowestThreadPriority) {

+ LOG_ERROR(Kernel_SVC, "Invalid thread priority specified (priority={})", priority);

+ return ResultInvalidPriority;

+ }

+ if (!thread) {

+ LOG_ERROR(Kernel_SVC, "Invalid handle provided (handle={:08X})", handle);

+ return ResultInvalidHandle;

+ }

+ if (core_id == IdealCoreUseProcessValue) {

+ if (!IsValidCoreId(core_id)) {

+ LOG_ERROR(Kernel_SVC, "Invalid Core ID specified (id={})", core_id);

+ return ResultInvalidCoreId;

+ }

+ if (((1ULL << core_id) & process.GetCoreMask()) == 0) {

+ LOG_ERROR(Kernel_SVC, "Core ID doesn't fall within allowable cores (id={})", core_id);

+ return ResultInvalidCoreId;

+ }

+ if (HighestThreadPriority > priority || priority > LowestThreadPriority) {

+ LOG_ERROR(Kernel_SVC, "Invalid priority specified (priority={})", priority);

+ return ResultInvalidPriority;

+ }

+ if (!process.CheckThreadPriority(priority)) {

+ LOG_ERROR(Kernel_SVC, "Invalid allowable thread priority (priority={})", priority);

+ return ResultInvalidPriority;

+ }

+ if (!thread) {

+ LOG_ERROR(Kernel_SVC, "Invalid thread handle provided (handle={:08X})", thread_handle);

+ return ResultInvalidHandle;

+ }

+ const auto run_result = thread->Run();

+ if (run_result.IsError()) {

+ LOG_ERROR(Kernel_SVC,

+ "Unable to successfuly start thread (thread handle={:08X}, result={})",

+ thread_handle, run_result.raw);

+ return run_result;

+ }

+ if (Memory::IsKernelAddress(address)) {

+ LOG_ERROR(Kernel_SVC, "Attempted to wait on kernel address (address={:08X})", address);

+ return ResultInvalidCurrentMemory;

+ }

+ if (!Common::IsAligned(address, sizeof(s32))) {

+ LOG_ERROR(Kernel_SVC, "Address must be 4 byte aligned (address={:08X})", address);

+ return ResultInvalidAddress;

+ }

+ if (Memory::IsKernelAddress(address)) {

+ LOG_ERROR(Kernel_SVC, "Attempting to wait on kernel address (address={:08X})", address);

+ return ResultInvalidCurrentMemory;

+ }

+ if (!Common::IsAligned(address, sizeof(s32))) {

+ LOG_ERROR(Kernel_SVC, "Wait address must be 4 byte aligned (address={:08X})", address);

+ return ResultInvalidAddress;

+ }

+ if (!IsValidArbitrationType(arb_type)) {

+ LOG_ERROR(Kernel_SVC, "Invalid arbitration type specified (type={})", arb_type);

+ return ResultInvalidEnumValue;

+ }

+ if (Memory::IsKernelAddress(address)) {

+ LOG_ERROR(Kernel_SVC, "Attempting to signal to a kernel address (address={:08X})", address);

+ return ResultInvalidCurrentMemory;

+ }

+ if (!Common::IsAligned(address, sizeof(s32))) {

+ LOG_ERROR(Kernel_SVC, "Signaled address must be 4 byte aligned (address={:08X})", address);

+ return ResultInvalidAddress;

+ }

+ if (!IsValidSignalType(signal_type)) {

+ LOG_ERROR(Kernel_SVC, "Invalid signal type specified (type={})", signal_type);

+ return ResultInvalidEnumValue;

+ }

+ // Get the current handle table.

+ // Try to reset as readable event.

+ {

+ auto readable_event = handle_table.Get<KReadableEvent>(handle);

+ if (readable_event) {

+ return readable_event->Reset();

+ }

+ // Try to reset as process.

+ {

+ auto process = handle_table.Get<Process>(handle);

+ if (process) {

+ return process->Reset();

+ }

+ LOG_ERROR(Kernel_SVC, "invalid handle (0x{:08X})", handle);

+

+ return Svc::ResultInvalidHandle;

+ if (!thread) {

+ LOG_ERROR(Kernel_SVC, "Invalid thread handle specified (handle={:08X})", thread_handle);

+ return ResultInvalidHandle;

+ }

+ const auto result = thread->GetCoreMask(out_core_id, out_affinity_mask);

+ if (result.IsError()) {

+ LOG_ERROR(Kernel_SVC, "Unable to successfully retrieve core mask (result={})", result.raw);

+ return result;

+ }

+ if ((affinity_mask | process_core_mask) != process_core_mask) {

+ LOG_ERROR(Kernel_SVC,

+ "Affinity mask does match the process core mask (affinity mask={:016X}, core "

+ "mask={:016X})",

+ affinity_mask, process_core_mask);

+ return ResultInvalidCoreId;

+ }

+ if (affinity_mask == 0) {

+ LOG_ERROR(Kernel_SVC, "Affinity mask is zero.");

+ return ResultInvalidCombination;

+ }

+ if (((1ULL << core_id) & affinity_mask) == 0) {

+ LOG_ERROR(Kernel_SVC, "Invalid core ID (ID={})", core_id);

+ return ResultInvalidCombination;

+ }

+ if (core_id != IdealCoreNoUpdate && core_id != IdealCoreDontCare) {

+ LOG_ERROR(Kernel_SVC, "Invalid core ID (ID={})", core_id);

+ return ResultInvalidCoreId;

+ }

+ if (!thread) {

+ LOG_ERROR(Kernel_SVC, "Invalid thread handle (handle={:08X})", thread_handle);

+ return ResultInvalidHandle;

+ }

+ const auto set_result = thread->SetCoreMask(core_id, affinity_mask);

+ if (set_result.IsError()) {

+ LOG_ERROR(Kernel_SVC, "Unable to successfully set core mask (result={})", set_result.raw);

+ return set_result;

+ }

+static ResultCode SignalEvent(Core::System& system, Handle event_handle) {

+ LOG_DEBUG(Kernel_SVC, "called, event_handle=0x{:08X}", event_handle);

+ // Get the current handle table.

+ const HandleTable& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();

+ // Get the writable event.

+ auto writable_event = handle_table.Get<KWritableEvent>(event_handle);

+ if (!writable_event) {

+ LOG_ERROR(Kernel_SVC, "Invalid event handle provided (handle={:08X})", event_handle);

+ return ResultInvalidHandle;

+ return writable_event->Signal();

+static ResultCode SignalEvent32(Core::System& system, Handle event_handle) {

+ return SignalEvent(system, event_handle);

+static ResultCode ClearEvent(Core::System& system, Handle event_handle) {

+ LOG_TRACE(Kernel_SVC, "called, event_handle=0x{:08X}", event_handle);

+ // Get the current handle table.

+ // Try to clear the writable event.

+ {

+ auto writable_event = handle_table.Get<KWritableEvent>(event_handle);

+ if (writable_event) {

+ return writable_event->Clear();

+ }

+ // Try to clear the readable event.

+ {

+ auto readable_event = handle_table.Get<KReadableEvent>(event_handle);

+ if (readable_event) {

+ return readable_event->Clear();

+ }

+ LOG_ERROR(Kernel_SVC, "Event handle does not exist, event_handle=0x{:08X}", event_handle);

+

+ return Svc::ResultInvalidHandle;

+static ResultCode ClearEvent32(Core::System& system, Handle event_handle) {

+ return ClearEvent(system, event_handle);

+static ResultCode CreateEvent(Core::System& system, Handle* out_write, Handle* out_read) {

+ LOG_DEBUG(Kernel_SVC, "called");

+

+ // Get the kernel reference and handle table.

+ auto& kernel = system.Kernel();

+ HandleTable& handle_table = kernel.CurrentProcess()->GetHandleTable();

+

+ // Create a new event.

+ const auto event = KEvent::Create(kernel, "CreateEvent");

+ if (!event) {

+ LOG_ERROR(Kernel_SVC, "Unable to create new events. Event creation limit reached.");

+ return ResultOutOfResource;

+ }

+ // Initialize the event.

+ event->Initialize();

+ // Add the writable event to the handle table.

+ const auto write_create_result = handle_table.Create(event->GetWritableEvent());

+ if (write_create_result.Failed()) {

+ return write_create_result.Code();

+ }

+ *out_write = *write_create_result;

+

+ // Add the writable event to the handle table.

+ auto handle_guard = SCOPE_GUARD({ handle_table.Close(*write_create_result); });

+

+ // Add the readable event to the handle table.

+ const auto read_create_result = handle_table.Create(event->GetReadableEvent());

+ if (read_create_result.Failed()) {

+ return read_create_result.Code();

+ *out_read = *read_create_result;

+ // We succeeded.

+ handle_guard.Cancel();

+static ResultCode CreateEvent32(Core::System& system, Handle* out_write, Handle* out_read) {

+ return CreateEvent(system, out_write, out_read);

+constexpr ResultCode ResultOutOfResource{ErrorModule::Kernel, 103};

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ launchable_event = Kernel::KEvent::Create(kernel, "ISelfController:LaunchableEvent");

+ launchable_event->Initialize();

+ accumulated_suspended_tick_changed_event =

+ Kernel::KEvent::Create(kernel, "ISelfController:AccumulatedSuspendedTickChangedEvent");

+ accumulated_suspended_tick_changed_event->Initialize();

+ accumulated_suspended_tick_changed_event->GetWritableEvent()->Signal();

+ launchable_event->GetWritableEvent()->Signal();

+ rb.PushCopyObjects(launchable_event->GetReadableEvent());

+ rb.PushCopyObjects(accumulated_suspended_tick_changed_event->GetReadableEvent());

+ on_new_message = Kernel::KEvent::Create(kernel, "AMMessageQueue:OnMessageReceived");

+ on_new_message->Initialize();

+ Kernel::KEvent::Create(kernel, "AMMessageQueue:OperationModeChanged");

+ on_operation_mode_changed->Initialize();

+const std::shared_ptr<Kernel::KReadableEvent>& AppletMessageQueue::GetMessageReceiveEvent() const {

+ return on_new_message->GetReadableEvent();

+const std::shared_ptr<Kernel::KReadableEvent>& AppletMessageQueue::GetOperationModeChangedEvent()

+ return on_operation_mode_changed->GetReadableEvent();

+ on_new_message->GetWritableEvent()->Signal();

+ on_new_message->GetWritableEvent()->Clear();

+ on_new_message->GetWritableEvent()->Clear();

+ on_operation_mode_changed->GetWritableEvent()->Signal();

+ {160, &IApplicationFunctions::GetHealthWarningDisappearedSystemEvent, "GetHealthWarningDisappearedSystemEvent"},

+ gpu_error_detected_event =

+ Kernel::KEvent::Create(kernel, "IApplicationFunctions:GpuErrorDetectedSystemEvent");

+ gpu_error_detected_event->Initialize();

+ friend_invitation_storage_channel_event =

+ Kernel::KEvent::Create(kernel, "IApplicationFunctions:FriendInvitationStorageChannelEvent");

+ friend_invitation_storage_channel_event->Initialize();

+ health_warning_disappeared_system_event =

+ Kernel::KEvent::Create(kernel, "IApplicationFunctions:HealthWarningDisappearedSystemEvent");

+ health_warning_disappeared_system_event->Initialize();

+ rb.PushCopyObjects(gpu_error_detected_event->GetReadableEvent());

+ rb.PushCopyObjects(friend_invitation_storage_channel_event->GetReadableEvent());

+void IApplicationFunctions::GetHealthWarningDisappearedSystemEvent(Kernel::HLERequestContext& ctx) {

+ LOG_DEBUG(Service_AM, "called");

+

+ IPC::ResponseBuilder rb{ctx, 2, 1};

+ rb.Push(RESULT_SUCCESS);

+ rb.PushCopyObjects(health_warning_disappeared_system_event->GetReadableEvent());

+}

+

+ pop_from_general_channel_event =

+ Kernel::KEvent::Create(system.Kernel(), "IHomeMenuFunctions:PopFromGeneralChannelEvent");

+ pop_from_general_channel_event->Initialize();

+ rb.PushCopyObjects(pop_from_general_channel_event->GetReadableEvent());

+

+class KEvent;

+ const std::shared_ptr<Kernel::KReadableEvent>& GetMessageReceiveEvent() const;

+ const std::shared_ptr<Kernel::KReadableEvent>& GetOperationModeChangedEvent() const;

+ std::shared_ptr<Kernel::KEvent> on_new_message;

+ std::shared_ptr<Kernel::KEvent> on_operation_mode_changed;

+ std::shared_ptr<Kernel::KEvent> launchable_event;

+ std::shared_ptr<Kernel::KEvent> accumulated_suspended_tick_changed_event;

+ void GetHealthWarningDisappearedSystemEvent(Kernel::HLERequestContext& ctx);

+ std::shared_ptr<Kernel::KEvent> gpu_error_detected_event;

+ std::shared_ptr<Kernel::KEvent> friend_invitation_storage_channel_event;

+ std::shared_ptr<Kernel::KEvent> health_warning_disappeared_system_event;

+ std::shared_ptr<Kernel::KEvent> pop_from_general_channel_event;

+

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ Kernel::KEvent::Create(kernel, "ILibraryAppletAccessor:StateChangedEvent");

+ state_changed_event->Initialize();

+ pop_out_data_event = Kernel::KEvent::Create(kernel, "ILibraryAppletAccessor:PopDataOutEvent");

+ pop_out_data_event->Initialize();

+ pop_interactive_out_data_event =

+ Kernel::KEvent::Create(kernel, "ILibraryAppletAccessor:PopInteractiveDataOutEvent");

+ pop_interactive_out_data_event->Initialize();

+ pop_out_data_event->GetWritableEvent()->Clear();

+ pop_interactive_out_data_event->GetWritableEvent()->Clear();

+ pop_out_data_event->GetWritableEvent()->Signal();

+ pop_interactive_out_data_event->GetWritableEvent()->Signal();

+ state_changed_event->GetWritableEvent()->Signal();

+std::shared_ptr<Kernel::KReadableEvent> AppletDataBroker::GetNormalDataEvent() const {

+ return pop_out_data_event->GetReadableEvent();

+std::shared_ptr<Kernel::KReadableEvent> AppletDataBroker::GetInteractiveDataEvent() const {

+ return pop_interactive_out_data_event->GetReadableEvent();

+std::shared_ptr<Kernel::KReadableEvent> AppletDataBroker::GetStateChangedEvent() const {

+ return state_changed_event->GetReadableEvent();

+

+class KEvent;

+class KReadableEvent;

+} // namespace Kernel

+ std::shared_ptr<Kernel::KReadableEvent> GetNormalDataEvent() const;

+ std::shared_ptr<Kernel::KReadableEvent> GetInteractiveDataEvent() const;

+ std::shared_ptr<Kernel::KReadableEvent> GetStateChangedEvent() const;

+ std::shared_ptr<Kernel::KEvent> state_changed_event;

+ std::shared_ptr<Kernel::KEvent> pop_out_data_event;

+ std::shared_ptr<Kernel::KEvent> pop_interactive_out_data_event;

+ .allow_pro_controller = npad_style_set.fullkey == 1,

+

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+ purchased_event =

+ Kernel::KEvent::Create(system.Kernel(), "IPurchaseEventManager:PurchasedEvent");

+ purchased_event->Initialize();

+ rb.PushCopyObjects(purchased_event->GetReadableEvent());

+ std::shared_ptr<Kernel::KEvent> purchased_event;

+ aoc_change_event = Kernel::KEvent::Create(kernel, "GetAddOnContentListChanged:Event");

+ aoc_change_event->Initialize();

+ rb.PushCopyObjects(aoc_change_event->GetReadableEvent());

+class KEvent;

+ std::shared_ptr<Kernel::KEvent> aoc_change_event;

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ buffer_event = Kernel::KEvent::Create(system.Kernel(), "IAudioOutBufferReleased");

+ buffer_event->Initialize();

+ buffer_event->GetWritableEvent()->Signal();

+ rb.PushCopyObjects(buffer_event->GetReadableEvent());

+ std::shared_ptr<Kernel::KEvent> buffer_event;

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ system_event = Kernel::KEvent::Create(system.Kernel(), "IAudioRenderer:SystemEvent");

+ system_event->Initialize();

+ system_event->GetWritableEvent()->Signal();

+ rb.PushCopyObjects(system_event->GetReadableEvent());

+ std::shared_ptr<Kernel::KEvent> system_event;

+ buffer_event = Kernel::KEvent::Create(kernel, "IAudioOutBufferReleasedEvent");

+ buffer_event->Initialize();

+ audio_input_device_switch_event =

+ Kernel::KEvent::Create(kernel, "IAudioDevice:AudioInputDeviceSwitchedEvent");

+ audio_input_device_switch_event->Initialize();

+ audio_output_device_switch_event =

+ Kernel::KEvent::Create(kernel, "IAudioDevice:AudioOutputDeviceSwitchedEvent");

+ audio_output_device_switch_event->Initialize();

+ buffer_event->GetWritableEvent()->Signal();

+ rb.PushCopyObjects(buffer_event->GetReadableEvent());

+ rb.PushCopyObjects(audio_input_device_switch_event->GetReadableEvent());

+ rb.PushCopyObjects(audio_output_device_switch_event->GetReadableEvent());

+ std::shared_ptr<Kernel::KEvent> buffer_event;

+ std::shared_ptr<Kernel::KEvent> audio_input_device_switch_event;

+ std::shared_ptr<Kernel::KEvent> audio_output_device_switch_event;

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ event = Kernel::KEvent::Create(kernel,

+ "ProgressServiceBackend:UpdateEvent:" + std::string(event_name));

+ event->Initialize();

+std::shared_ptr<Kernel::KReadableEvent> ProgressServiceBackend::GetEvent() const {

+ return event->GetReadableEvent();

+ event->GetWritableEvent()->Signal();

+ event->GetWritableEvent()->Signal();

+class KEvent;

+class KReadableEvent;

+} // namespace Kernel

+ std::shared_ptr<Kernel::KReadableEvent> GetEvent() const;

+ std::shared_ptr<Kernel::KEvent> event;

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ std::shared_ptr<Kernel::KReadableEvent> event_,

+ std::shared_ptr<Kernel::KReadableEvent> event;

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+ register_event = Kernel::KEvent::Create(kernel, "BT:RegisterEvent");

+ register_event->Initialize();

+ rb.PushCopyObjects(register_event->GetReadableEvent());

+ std::shared_ptr<Kernel::KEvent> register_event;

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+ scan_event = Kernel::KEvent::Create(kernel, "IBtmUserCore:ScanEvent");

+ scan_event->Initialize();

+ connection_event = Kernel::KEvent::Create(kernel, "IBtmUserCore:ConnectionEvent");

+ connection_event->Initialize();

+ service_discovery = Kernel::KEvent::Create(kernel, "IBtmUserCore:Discovery");

+ service_discovery->Initialize();

+ config_event = Kernel::KEvent::Create(kernel, "IBtmUserCore:ConfigEvent");

+ config_event->Initialize();

+ rb.PushCopyObjects(scan_event->GetReadableEvent());

+ rb.PushCopyObjects(connection_event->GetReadableEvent());

+ rb.PushCopyObjects(service_discovery->GetReadableEvent());

+ rb.PushCopyObjects(config_event->GetReadableEvent());

+ std::shared_ptr<Kernel::KEvent> scan_event;

+ std::shared_ptr<Kernel::KEvent> connection_event;

+ std::shared_ptr<Kernel::KEvent> service_discovery;

+ std::shared_ptr<Kernel::KEvent> config_event;

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ notification_event =

+ Kernel::KEvent::Create(system.Kernel(), "INotificationService:NotifyEvent");

+ notification_event->Initialize();

+ rb.PushCopyObjects(notification_event->GetReadableEvent());

+ std::shared_ptr<Kernel::KEvent> notification_event;

+ using namespace Settings::NativeKeyboard;

+

+ // TODO: Assign the correct key to all modifiers

+ cur_entry.modifier.control.Assign(keyboard_mods[LeftControl]->GetStatus());

+ cur_entry.modifier.shift.Assign(keyboard_mods[LeftShift]->GetStatus());

+ cur_entry.modifier.left_alt.Assign(keyboard_mods[LeftAlt]->GetStatus());

+ cur_entry.modifier.right_alt.Assign(keyboard_mods[RightAlt]->GetStatus());

+ cur_entry.modifier.gui.Assign(0);

+ cur_entry.modifier.caps_lock.Assign(keyboard_mods[CapsLock]->GetStatus());

+ cur_entry.modifier.scroll_lock.Assign(keyboard_mods[ScrollLock]->GetStatus());

+ cur_entry.modifier.num_lock.Assign(keyboard_mods[NumLock]->GetStatus());

+ cur_entry.modifier.katakana.Assign(0);

+ cur_entry.modifier.hiragana.Assign(0);

+#include "common/bit_field.h"

+ struct Modifiers {

+ union {

+ u32_le raw{};

+ BitField<0, 1, u32> control;

+ BitField<1, 1, u32> shift;

+ BitField<2, 1, u32> left_alt;

+ BitField<3, 1, u32> right_alt;

+ BitField<4, 1, u32> gui;

+ BitField<8, 1, u32> caps_lock;

+ BitField<9, 1, u32> scroll_lock;

+ BitField<10, 1, u32> num_lock;

+ BitField<11, 1, u32> katakana;

+ BitField<12, 1, u32> hiragana;

+ };

+ };

+ static_assert(sizeof(Modifiers) == 0x4, "Modifiers is an invalid size");

+

+ Modifiers modifier;

+ cur_entry.attribute.raw = 0;

+ cur_entry.attribute.is_connected.Assign(1);

+ using namespace Settings::NativeMouseButton;

+ cur_entry.button.left.Assign(mouse_button_devices[Left]->GetStatus());

+ cur_entry.button.right.Assign(mouse_button_devices[Right]->GetStatus());

+ cur_entry.button.middle.Assign(mouse_button_devices[Middle]->GetStatus());

+ cur_entry.button.forward.Assign(mouse_button_devices[Forward]->GetStatus());

+ cur_entry.button.back.Assign(mouse_button_devices[Back]->GetStatus());

+#include "common/bit_field.h"

+ struct Buttons {

+ union {

+ u32_le raw{};

+ BitField<0, 1, u32> left;

+ BitField<1, 1, u32> right;

+ BitField<2, 1, u32> middle;

+ BitField<3, 1, u32> forward;

+ BitField<4, 1, u32> back;

+ };

+ };

+ static_assert(sizeof(Buttons) == 0x4, "Buttons is an invalid size");

+

+ struct Attributes {

+ union {

+ u32_le raw{};

+ BitField<0, 1, u32> transferable;

+ BitField<1, 1, u32> is_connected;

+ };

+ };

+ static_assert(sizeof(Attributes) == 0x4, "Attributes is an invalid size");

+

+ Buttons button;

+ Attributes attribute;

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ styleset_changed_events[controller_idx]->GetWritableEvent()->Signal();

+ controller.style_set.raw = 0; // Zero out

+ controller.system_properties.raw = 0;

+ controller.style_set.fullkey.Assign(1);

+ controller.device_type.fullkey.Assign(1);

+ controller.system_properties.is_vertical.Assign(1);

+ controller.system_properties.use_plus.Assign(1);

+ controller.system_properties.use_minus.Assign(1);

+ controller.assignment_mode = NpadAssignments::Single;

+ controller.footer_type = AppletFooterUiType::SwitchProController;

+ controller.style_set.handheld.Assign(1);

+ controller.device_type.handheld_left.Assign(1);

+ controller.device_type.handheld_right.Assign(1);

+ controller.system_properties.is_vertical.Assign(1);

+ controller.system_properties.use_plus.Assign(1);

+ controller.system_properties.use_minus.Assign(1);

+ controller.assignment_mode = NpadAssignments::Dual;

+ controller.footer_type = AppletFooterUiType::HandheldJoyConLeftJoyConRight;

+ controller.style_set.joycon_dual.Assign(1);

+ controller.system_properties.is_vertical.Assign(1);

+ controller.system_properties.use_plus.Assign(1);

+ controller.system_properties.use_minus.Assign(1);

+ controller.assignment_mode = NpadAssignments::Dual;

+ controller.footer_type = AppletFooterUiType::JoyDual;

+ controller.style_set.joycon_left.Assign(1);

+ controller.system_properties.is_horizontal.Assign(1);

+ controller.system_properties.use_minus.Assign(1);

+ controller.assignment_mode = NpadAssignments::Single;

+ controller.footer_type = AppletFooterUiType::JoyLeftHorizontal;

+ controller.style_set.joycon_right.Assign(1);

+ controller.system_properties.is_horizontal.Assign(1);

+ controller.system_properties.use_plus.Assign(1);

+ controller.assignment_mode = NpadAssignments::Single;

+ controller.footer_type = AppletFooterUiType::JoyRightHorizontal;

+ controller.style_set.palma.Assign(1);

+ controller.device_type.palma.Assign(1);

+ controller.assignment_mode = NpadAssignments::Single;

+ controller.fullkey_color.attribute = ColorAttributes::Ok;

+ controller.fullkey_color.fullkey.body = 0;

+ controller.fullkey_color.fullkey.button = 0;

+ controller.joycon_color.attribute = ColorAttributes::Ok;

+ controller.joycon_color.left.body =

+ controller.joycon_color.left.button =

+ controller.joycon_color.right.body =

+ controller.joycon_color.right.button =

+ // TODO: Investigate when we should report all batery types

+ controller.battery_level_dual = BATTERY_FULL;

+ controller.battery_level_left = BATTERY_FULL;

+ controller.battery_level_right = BATTERY_FULL;

+ styleset_changed_events[i] =

+ Kernel::KEvent::Create(kernel, fmt::format("npad:NpadStyleSetChanged_{}", i));

+ styleset_changed_events[i]->Initialize();

+ style.fullkey.Assign(1);

+ style.palma.Assign(1);

+ const std::array<NPadGeneric*, 7> controller_npads{

+ &npad.fullkey_states, &npad.handheld_states, &npad.joy_dual_states,

+ &npad.joy_left_states, &npad.joy_right_states, &npad.palma_states,

+ &npad.system_ext_states};

+ npad.fullkey_states.npad[npad.fullkey_states.common.last_entry_index];

+ auto& dual_entry = npad.joy_dual_states.npad[npad.joy_dual_states.common.last_entry_index];

+ auto& left_entry = npad.joy_left_states.npad[npad.joy_left_states.common.last_entry_index];

+ npad.joy_right_states.npad[npad.joy_right_states.common.last_entry_index];

+ auto& pokeball_entry = npad.palma_states.npad[npad.palma_states.common.last_entry_index];

+ auto& libnx_entry =

+ npad.system_ext_states.npad[npad.system_ext_states.common.last_entry_index];

+ libnx_entry.connection_status.is_connected.Assign(1);

+ main_controller.connection_status.is_connected.Assign(1);

+ main_controller.connection_status.is_wired.Assign(1);

+ libnx_entry.connection_status.is_wired.Assign(1);

+ handheld_entry.connection_status.is_connected.Assign(1);

+ handheld_entry.connection_status.is_wired.Assign(1);

+ handheld_entry.connection_status.is_left_connected.Assign(1);

+ handheld_entry.connection_status.is_right_connected.Assign(1);

+ handheld_entry.connection_status.is_left_wired.Assign(1);

+ handheld_entry.connection_status.is_right_wired.Assign(1);

+ libnx_entry.connection_status.is_wired.Assign(1);

+ libnx_entry.connection_status.is_left_connected.Assign(1);

+ libnx_entry.connection_status.is_right_connected.Assign(1);

+ libnx_entry.connection_status.is_left_wired.Assign(1);

+ libnx_entry.connection_status.is_right_wired.Assign(1);

+ dual_entry.connection_status.is_connected.Assign(1);

+ dual_entry.connection_status.is_left_connected.Assign(1);

+ dual_entry.connection_status.is_right_connected.Assign(1);

+ libnx_entry.connection_status.is_left_connected.Assign(1);

+ libnx_entry.connection_status.is_right_connected.Assign(1);

+ left_entry.connection_status.is_connected.Assign(1);

+ left_entry.connection_status.is_left_connected.Assign(1);

+ libnx_entry.connection_status.is_left_connected.Assign(1);

+ right_entry.connection_status.is_connected.Assign(1);

+ right_entry.connection_status.is_right_connected.Assign(1);

+ libnx_entry.connection_status.is_right_connected.Assign(1);

+ pokeball_entry.connection_status.is_connected.Assign(1);

+ &npad.sixaxis_fullkey, &npad.sixaxis_handheld, &npad.sixaxis_dual_left,

+ npad.sixaxis_fullkey.sixaxis[npad.sixaxis_fullkey.common.last_entry_index];

+ full_sixaxis_entry.attribute.raw = 0;

+ full_sixaxis_entry.attribute.is_connected.Assign(1);

+ handheld_sixaxis_entry.attribute.raw = 0;

+ handheld_sixaxis_entry.attribute.is_connected.Assign(1);

+ dual_left_sixaxis_entry.attribute.raw = 0;

+ dual_right_sixaxis_entry.attribute.raw = 0;

+ dual_left_sixaxis_entry.attribute.is_connected.Assign(1);

+ dual_right_sixaxis_entry.attribute.is_connected.Assign(1);

+ left_sixaxis_entry.attribute.raw = 0;

+ left_sixaxis_entry.attribute.is_connected.Assign(1);

+ right_sixaxis_entry.attribute.raw = 0;

+ right_sixaxis_entry.attribute.is_connected.Assign(1);

+ if (shared_memory_entries[npad_index].assignment_mode != assignment_mode) {

+ shared_memory_entries[npad_index].assignment_mode = assignment_mode;

+std::shared_ptr<Kernel::KReadableEvent> Controller_NPad::GetStyleSetChangedEvent(

+ u32 npad_id) const {

+ return styleset_event->GetReadableEvent();

+ styleset_changed_events[NPadIdToIndex(npad_id)]->GetWritableEvent()->Signal();

+ controller.style_set.raw = 0; // Zero out

+ controller.system_properties.raw = 0;

+ controller.button_properties.raw = 0;

+ controller.battery_level_dual = 0;

+ controller.battery_level_left = 0;

+ controller.battery_level_right = 0;

+ controller.fullkey_color = {};

+ controller.joycon_color = {};

+ controller.assignment_mode = NpadAssignments::Dual;

+ controller.footer_type = AppletFooterUiType::None;

+ return style.fullkey;

+ return style.palma;

+namespace Kernel {

+class KEvent;

+class KReadableEvent;

+} // namespace Kernel

+

+ Mode_5ms = 0,

+ Mode_10ms = 1,

+ Mode_15ms = 2,

+ Default = 3,

+ BitField<0, 1, u32> fullkey;

+ BitField<5, 1, u32> gamecube;

+ BitField<6, 1, u32> palma;

+ BitField<7, 1, u32> lark;

+ BitField<8, 1, u32> handheld_lark;

+ BitField<9, 1, u32> lucia;

+ BitField<29, 1, u32> system_ext;

+ BitField<30, 1, u32> system;

+ std::shared_ptr<Kernel::KReadableEvent> GetStyleSetChangedEvent(u32 npad_id) const;

+ enum class ColorAttributes : u32_le {

+ Ok = 0,

+ ReadError = 1,

+ NoController = 2,

+ };

+ static_assert(sizeof(ColorAttributes) == 4, "ColorAttributes is an invalid size");

+

+ u32_le body;

+ u32_le button;

+ struct FullKeyColor {

+ ColorAttributes attribute;

+ ControllerColor fullkey;

+ };

+ static_assert(sizeof(FullKeyColor) == 0xC, "FullKeyColor is an invalid size");

+

+ struct JoyconColor {

+ ColorAttributes attribute;

+ ControllerColor left;

+ ControllerColor right;

+ };

+ static_assert(sizeof(JoyconColor) == 0x14, "JoyconColor is an invalid size");

+

+

+ BitField<28, 1, u64> palma;

+ BitField<30, 1, u64> handheld_left_b;

+ BitField<0, 1, u32> is_connected;

+ BitField<1, 1, u32> is_wired;

+ BitField<2, 1, u32> is_left_connected;

+ BitField<3, 1, u32> is_left_wired;

+ BitField<4, 1, u32> is_right_connected;

+ BitField<5, 1, u32> is_right_wired;

+ struct SixAxisAttributes {

+ union {

+ u32_le raw{};

+ BitField<0, 1, u32> is_connected;

+ BitField<1, 1, u32> is_interpolated;

+ };

+ };

+ static_assert(sizeof(SixAxisAttributes) == 4, "SixAxisAttributes is an invalid size");

+

+ SixAxisAttributes attribute;

+ INSERT_PADDING_BYTES(4); // Reserved

+ struct NPadSystemProperties {

+ BitField<0, 1, s64> is_charging_joy_dual;

+ BitField<1, 1, s64> is_charging_joy_left;

+ BitField<2, 1, s64> is_charging_joy_right;

+ BitField<3, 1, s64> is_powered_joy_dual;

+ BitField<4, 1, s64> is_powered_joy_left;

+ BitField<5, 1, s64> is_powered_joy_right;

+ BitField<9, 1, s64> is_system_unsupported_button;

+ BitField<10, 1, s64> is_system_ext_unsupported_button;

+ BitField<15, 1, s64> use_directional_buttons;

+ };

+ };

+ static_assert(sizeof(NPadSystemProperties) == 0x8, "NPadSystemProperties is an invalid size");

+

+ struct NPadButtonProperties {

+ union {

+ s32_le raw{};

+ BitField<0, 1, s32> is_home_button_protection_enabled;

+ static_assert(sizeof(NPadButtonProperties) == 0x4, "NPadButtonProperties is an invalid size");

+ BitField<0, 1, s32> fullkey;

+ BitField<1, 1, s32> debug_pad;

+ BitField<6, 1, s32> palma;

+ BitField<7, 1, s32> lark_hvc_left;

+ BitField<8, 1, s32> lark_hvc_right;

+ BitField<9, 1, s32> lark_nes_left;

+ BitField<10, 1, s32> lark_nes_right;

+ BitField<11, 1, s32> handheld_lark_hvc_left;

+ BitField<12, 1, s32> handheld_lark_hvc_right;

+ BitField<13, 1, s32> handheld_lark_nes_left;

+ BitField<14, 1, s32> handheld_lark_nes_right;

+ BitField<15, 1, s32> lucia;

+ BitField<31, 1, s32> system;

+ struct NfcXcdHandle {

+ INSERT_PADDING_BYTES(0x60);

+ };

+ struct AppletFooterUiAttributes {

+ INSERT_PADDING_BYTES(0x4);

+ };

+ enum class AppletFooterUiType : u8 {

+ None = 0,

+ HandheldNone = 1,

+ HandheldJoyConLeftOnly = 1,

+ HandheldJoyConRightOnly = 3,

+ HandheldJoyConLeftJoyConRight = 4,

+ JoyDual = 5,

+ JoyDualLeftOnly = 6,

+ JoyDualRightOnly = 7,

+ JoyLeftHorizontal = 8,

+ JoyLeftVertical = 9,

+ JoyRightHorizontal = 10,

+ JoyRightVertical = 11,

+ SwitchProController = 12,

+ CompatibleProController = 13,

+ CompatibleJoyCon = 14,

+ LarkHvc1 = 15,

+ LarkHvc2 = 16,

+ LarkNesLeft = 17,

+ LarkNesRight = 18,

+ Lucia = 19,

+ Verification = 20,

+ };

+

+ struct NPadEntry {

+ NpadStyleSet style_set;

+ NpadAssignments assignment_mode;

+ FullKeyColor fullkey_color;

+ JoyconColor joycon_color;

+ NPadGeneric fullkey_states;

+ NPadGeneric joy_dual_states;

+ NPadGeneric joy_left_states;

+ NPadGeneric joy_right_states;

+ NPadGeneric palma_states;

+ NPadGeneric system_ext_states;

+ SixAxisGeneric sixaxis_fullkey;

+ INSERT_PADDING_BYTES(0x4); // reserved

+ NPadSystemProperties system_properties;

+ NPadButtonProperties button_properties;

+ u32 battery_level_dual;

+ u32 battery_level_left;

+ u32 battery_level_right;

+ AppletFooterUiAttributes footer_attributes;

+ AppletFooterUiType footer_type;

+ // nfc_states needs to be checked switchbrew does not match with HW

+ NfcXcdHandle nfc_states;

+ INSERT_PADDING_BYTES(0xdef);

+ NpadCommunicationMode communication_mode{NpadCommunicationMode::Default};

+ std::array<std::shared_ptr<Kernel::KEvent>, 10> styleset_changed_events;

+#include "common/bit_field.h"

+ struct Attributes {

+ union {

+ u32_le raw{};

+ BitField<0, 1, u32> is_connected;

+ BitField<1, 1, u32> is_wired;

+ BitField<2, 1, u32> is_left_connected;

+ BitField<3, 1, u32> is_left_wired;

+ BitField<4, 1, u32> is_right_connected;

+ BitField<5, 1, u32> is_right_wired;

+ };

+ };

+ static_assert(sizeof(Attributes) == 4, "Attributes is an invalid size");

+

+ struct Buttons {

+ union {

+ u32_le raw{};

+ // Button states

+ BitField<0, 1, u32> a;

+ BitField<1, 1, u32> b;

+ BitField<2, 1, u32> x;

+ BitField<3, 1, u32> y;

+ BitField<4, 1, u32> l_stick;

+ BitField<5, 1, u32> r_stick;

+ BitField<6, 1, u32> l;

+ BitField<7, 1, u32> r;

+ BitField<8, 1, u32> zl;

+ BitField<9, 1, u32> zr;

+ BitField<10, 1, u32> plus;

+ BitField<11, 1, u32> minus;

+

+ // D-Pad

+ BitField<12, 1, u32> d_left;

+ BitField<13, 1, u32> d_up;

+ BitField<14, 1, u32> d_right;

+ BitField<15, 1, u32> d_down;

+

+ // Left JoyStick

+ BitField<16, 1, u32> l_stick_left;

+ BitField<17, 1, u32> l_stick_up;

+ BitField<18, 1, u32> l_stick_right;

+ BitField<19, 1, u32> l_stick_down;

+

+ // Right JoyStick

+ BitField<20, 1, u32> r_stick_left;

+ BitField<21, 1, u32> r_stick_up;

+ BitField<22, 1, u32> r_stick_right;

+ BitField<23, 1, u32> r_stick_down;

+

+ // Not always active?

+ BitField<24, 1, u32> left_sl;

+ BitField<25, 1, u32> left_sr;

+

+ BitField<26, 1, u32> right_sl;

+ BitField<27, 1, u32> right_sr;

+

+ BitField<28, 1, u32> palma;

+ BitField<30, 1, u32> handheld_left_b;

+ };

+ };

+ static_assert(sizeof(Buttons) == 4, "Buttons is an invalid size");

+

+ Attributes attributes;

+ Buttons pad_states;

+ AnalogStick l_stick;

+ AnalogStick r_stick;

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ MakeController<Controller_Stubbed>(HidController::HomeButton);

+ MakeController<Controller_Stubbed>(HidController::SleepButton);

+ MakeController<Controller_Stubbed>(HidController::CaptureButton);

+ MakeController<Controller_Stubbed>(HidController::InputDetector);

+ MakeController<Controller_Stubbed>(HidController::UniquePad);

+ MakeController<Controller_Stubbed>(HidController::ConsoleSixAxisSensor);

+ GetController<Controller_Stubbed>(HidController::HomeButton).SetCommonHeaderOffset(0x4C00);

+ GetController<Controller_Stubbed>(HidController::SleepButton).SetCommonHeaderOffset(0x4E00);

+ GetController<Controller_Stubbed>(HidController::CaptureButton).SetCommonHeaderOffset(0x5000);

+ GetController<Controller_Stubbed>(HidController::InputDetector).SetCommonHeaderOffset(0x5200);

+ GetController<Controller_Stubbed>(HidController::UniquePad).SetCommonHeaderOffset(0x5A00);

+ GetController<Controller_Stubbed>(HidController::ConsoleSixAxisSensor)

+ .SetCommonHeaderOffset(0x3C200);

+ system.CoreTiming().UnscheduleEvent(motion_update_event, 0);

+ HomeButton,

+ SleepButton,

+ CaptureButton,

+ InputDetector,

+ UniquePad,

+ ConsoleSixAxisSensor,

+ u64 ReadLeb128(const std::vector<u8>& data, std::size_t& offset) {

+ u64 result{};

+

+ for (std::size_t i = 0; i < sizeof(u64); i++) {

+ const auto v = data[offset];

+ result |= (static_cast<u64>(v & 0x7f) << shift);

+ if (offset >= data.size() || ((v & 0x80) == 0)) {

+ }

+ LOG_DEBUG(Service_LM, "LogManager TRACE ({}):\n{}", DestinationToString(destination),

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ nfc_tag_load = Kernel::KEvent::Create(kernel, "IUser:NFCTagDetected");

+ nfc_tag_load->Initialize();

+ deactivate_event = Kernel::KEvent::Create(kernel, "IUser:DeactivateEvent");

+ deactivate_event->Initialize();

+ availability_change_event = Kernel::KEvent::Create(kernel, "IUser:AvailabilityChangeEvent");

+ availability_change_event->Initialize();

+ rb.PushCopyObjects(deactivate_event->GetReadableEvent());

+ deactivate_event->GetWritableEvent()->Signal();

+ rb.PushCopyObjects(availability_change_event->GetReadableEvent());

+ std::shared_ptr<Kernel::KEvent> deactivate_event;

+ std::shared_ptr<Kernel::KEvent> availability_change_event;

+ nfc_tag_load->GetWritableEvent()->Signal();

+const std::shared_ptr<Kernel::KReadableEvent>& Module::Interface::GetNFCEvent() const {

+ return nfc_tag_load->GetReadableEvent();

+

+namespace Kernel {

+class KEvent;

+}

+

+ const std::shared_ptr<Kernel::KReadableEvent>& GetNFCEvent() const;

+ std::shared_ptr<Kernel::KEvent> nfc_tag_load;

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+

+ event1 = Kernel::KEvent::Create(kernel, "IRequest:Event1");

+ event1->Initialize();

+ event2 = Kernel::KEvent::Create(kernel, "IRequest:Event2");

+ event2->Initialize();

+ rb.PushCopyObjects(event1->GetReadableEvent(), event2->GetReadableEvent());

+ std::shared_ptr<Kernel::KEvent> event1, event2;

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ finished_event =

+ Kernel::KEvent::Create(kernel, "IEnsureNetworkClockAvailabilityService:FinishEvent");

+ finished_event->Initialize();

+ std::shared_ptr<Kernel::KEvent> finished_event;

+ finished_event->GetWritableEvent()->Signal();

+ rb.PushCopyObjects(finished_event->GetReadableEvent());

+ finished_event->GetWritableEvent()->Clear();

+ if (input.size() < 2) {

+ LOG_ERROR(Service_NS, "Input font is empty");

+ return;

+ }

+

+ std::memcpy(output.data(), transformed_font.data() + 2,

+ (transformed_font.size() - 2) * sizeof(u32));

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ event.event->GetWritableEvent()->Signal();

+ event.event->GetWritableEvent()->Signal();

+ event.event->GetWritableEvent()->Clear();

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+class KWritableEvent;

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ events_interface.events[i] = {Kernel::KEvent::Create(kernel, std::move(event_label))};

+ events_interface.events[i].event->Initialize();

+ events_interface.events[i].event->GetWritableEvent()->Signal();

+std::shared_ptr<Kernel::KReadableEvent> Module::GetEvent(const u32 event_id) const {

+ return events_interface.events[event_id].event->GetReadableEvent();

+std::shared_ptr<Kernel::KWritableEvent> Module::GetEventWriteable(const u32 event_id) const {

+ return events_interface.events[event_id].event->GetWritableEvent();

+

+namespace Kernel {

+class KEvent;

+}

+

+ std::shared_ptr<Kernel::KEvent> event;

+ std::shared_ptr<Kernel::KReadableEvent> GetEvent(u32 event_id) const;

+ std::shared_ptr<Kernel::KWritableEvent> GetEventWriteable(u32 event_id) const;

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ buffer_wait_event = Kernel::KEvent::Create(kernel, "BufferQueue:WaitEvent");

+ buffer_wait_event->Initialize();

+ buffer_wait_event->GetWritableEvent()->Signal();

+ buffer_wait_event->GetWritableEvent()->Signal();

+ buffer_wait_event->GetWritableEvent()->Signal();

+ buffer_wait_event->GetWritableEvent()->Signal();

+std::shared_ptr<Kernel::KWritableEvent> BufferQueue::GetWritableBufferWaitEvent() const {

+ return buffer_wait_event->GetWritableEvent();

+std::shared_ptr<Kernel::KReadableEvent> BufferQueue::GetBufferWaitEvent() const {

+ return buffer_wait_event->GetReadableEvent();

+class KEvent;

+class KReadableEvent;

+class KWritableEvent;

+} // namespace Kernel

+ std::shared_ptr<Kernel::KWritableEvent> GetWritableBufferWaitEvent() const;

+ std::shared_ptr<Kernel::KReadableEvent> GetBufferWaitEvent() const;

+ std::shared_ptr<Kernel::KEvent> buffer_wait_event;

+#include "core/hle/kernel/k_readable_event.h"

+std::shared_ptr<Kernel::KReadableEvent> NVFlinger::FindVsyncEvent(u64 display_id) const {

+class KReadableEvent;

+class KWritableEvent;

+ [[nodiscard]] std::shared_ptr<Kernel::KReadableEvent> FindVsyncEvent(u64 display_id) const;

+ {13, &OLSC::GetSaveDataBackupSetting, "GetSaveDataBackupSetting"},

+ void GetSaveDataBackupSetting(Kernel::HLERequestContext& ctx) {

+ LOG_WARNING(Service_OLSC, "(STUBBED) called");

+

+ // backup_setting is set to 0 since real value is unknown

+ constexpr u64 backup_setting = 0;

+

+ IPC::ResponseBuilder rb{ctx, 4};

+ rb.Push(RESULT_SUCCESS);

+ rb.Push(backup_setting);

+ }

+

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ state_change_event =

+ Kernel::KEvent::Create(system_.Kernel(), "IPsmSession::state_change_event");

+ state_change_event->Initialize();

+ state_change_event->GetWritableEvent()->Signal();

+ state_change_event->GetWritableEvent()->Signal();

+ state_change_event->GetWritableEvent()->Signal();

+ rb.PushCopyObjects(state_change_event->GetReadableEvent());

+ std::shared_ptr<Kernel::KEvent> state_change_event;

+#include "core/hle/kernel/k_event.h"

+ auto_correction_event{Kernel::KEvent::Create(

+ system.Kernel(), "StandardUserSystemClockCore:AutoCorrectionEvent")} {

+ auto_correction_event->Initialize();

+}

+namespace Kernel {

+class KEvent;

+}

+

+ std::shared_ptr<Kernel::KEvent> auto_correction_event;

+#include "core/hle/kernel/k_writable_event.h"

+ std::shared_ptr<Kernel::KWritableEvent>&& writable_event) {

+class KWritableEvent;

+ void RegisterOperationEvent(std::shared_ptr<Kernel::KWritableEvent>&& writable_event);

+ std::vector<std::shared_ptr<Kernel::KWritableEvent>> operation_event_list;

+#include "core/hle/kernel/k_event.h"

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ vsync_event = Kernel::KEvent::Create(kernel, fmt::format("Display VSync Event {}", id));

+ vsync_event->Initialize();

+std::shared_ptr<Kernel::KReadableEvent> Display::GetVSyncEvent() const {

+ return vsync_event->GetReadableEvent();

+ vsync_event->GetWritableEvent()->Signal();

+

+namespace Kernel {

+class KEvent;

+}

+ std::shared_ptr<Kernel::KReadableEvent> GetVSyncEvent() const;

+ std::shared_ptr<Kernel::KEvent> vsync_event;

+#include "core/hle/kernel/k_readable_event.h"

+#include "core/hle/kernel/k_writable_event.h"

+ Input::AnalogProperties GetAnalogProperties() const override {

+ return {modifier_scale, 1.0f, 0.5f};

+ }

+

+ std::tuple<float, float> GetRawStatus() const override {

+ const float x = GetAxis(axis_x);

+ const float y = GetAxis(axis_y);

+ return {x, y};

+ }

+

+ Input::AnalogProperties GetAnalogProperties() const override {

+ return {deadzone, range, 0.5f};

+ }

+

+ std::tuple<float, float> GetRawStatus() const override {

+ const float x = GetAxis(axis_x);

+ const float y = GetAxis(axis_y);

+ return {x, y};

+ }

+

+ Input::AnalogProperties GetAnalogProperties() const override {

+ return {deadzone, range, 0.5f};

+ }

+

+ std::tuple<float, float> GetRawStatus() const override {

+ const float x = joystick->GetAxis(axis_x, range);

+ const float y = joystick->GetAxis(axis_y, range);

+ return {x, -y};

+ }

+

+ Input::AnalogProperties GetAnalogProperties() const override {

+ return {deadzone, range, 0.5f};

+ }

+

+ RingBuffer<char, 4> buf;

+ RingBuffer<char, 8> buf;

+ if (const std::size_t c = buf.Push(&value[0], 2); c > 0) {

+ REQUIRE(c == 2U);

+ if (const std::vector<char> v = buf.Pop(2); v.size() > 0) {

+ if (!GLAD_GL_VERSION_4_6) {

+ configuration/configure_input_player_widget.cpp

+ configuration/configure_input_player_widget.h

+ debugger/controller.cpp

+ debugger/controller.h

+ format.setVersion(4, 6);

+ if (!GLAD_GL_VERSION_4_6) {

+ LOG_ERROR(Frontend, "GPU does not support OpenGL 4.6: {}", renderer.toStdString());

+ QMessageBox::warning(this, tr("Error while initializing OpenGL 4.6!"),

+ tr("Your GPU may not support OpenGL 4.6, or you do not have the "

+ if (!GLAD_GL_EXT_texture_compression_s3tc) {

+ }

+ if (!GLAD_GL_ARB_texture_compression_rgtc) {

+ }

+#include "yuzu/configuration/configure_input_player_widget.h"

+ const auto ConfigureButtonClick = [&](QPushButton* button, std::size_t button_id,

+ Common::ParamPackage* param, int default_val,

+ InputCommon::Polling::DeviceType type) {

+ button, button_id,

+ ConfigureButtonClick(button_map[button_id], button_id, &buttons_param[button_id],

+ ui->controllerFrame->SetPlayerInput(player_index, buttons_param, analogs_param);

+ ConfigureButtonClick(motion_map[motion_id], motion_id, &motions_param[motion_id],

+ analog_map_buttons[analog_id][sub_button_id], analog_id,

+ connect(

+ analog_button, &QPushButton::customContextMenuRequested,

+ [=, this](const QPoint& menu_location) {

+ QMenu context_menu;

+ context_menu.addAction(tr("Clear"), [&] {

+ analogs_param[analog_id].Clear();

+ analog_map_buttons[analog_id][sub_button_id]->setText(tr("[not set]"));

+ });

+ context_menu.addAction(tr("Invert axis"), [&] {

+ if (sub_button_id == 2 || sub_button_id == 3) {

+ const bool invert_value =

+ analogs_param[analog_id].Get("invert_x", "+") == "-";

+ const std::string invert_str = invert_value ? "+" : "-";

+ analogs_param[analog_id].Set("invert_x", invert_str);

+ }

+ if (sub_button_id == 0 || sub_button_id == 1) {

+ const bool invert_value =

+ analogs_param[analog_id].Get("invert_y", "+") == "-";

+ const std::string invert_str = invert_value ? "+" : "-";

+ analogs_param[analog_id].Set("invert_y", invert_str);

+ }

+ for (int sub_button_id = 0; sub_button_id < ANALOG_SUB_BUTTONS_NUM;

+ ++sub_button_id) {

+ analog_map_buttons[analog_id][sub_button_id]->setText(AnalogToText(

+ analogs_param[analog_id], analog_sub_buttons[sub_button_id]));

+ }

+ context_menu.exec(

+ analog_map_buttons[analog_id][sub_button_id]->mapToGlobal(menu_location));

+ ui->controllerFrame->SetPlayerInput(player_index, buttons_param, analogs_param);

+ });

+ analog_map_modifier_button[analog_id], analog_id,

+ ui->controllerFrame->SetPlayerInput(player_index, buttons_param, analogs_param);

+ ui->controllerFrame->SetPlayerInput(player_index, buttons_param, analogs_param);

+ connect(ui->groupConnectedController, &QGroupBox::toggled, [this](bool checked) {

+ emit Connected(checked);

+ ui->controllerFrame->SetConnectedStatus(checked);

+ });

+ ui->controllerFrame->SetPlayerInput(player_index, buttons_param, analogs_param);

+ ui->controllerFrame->SetConnectedStatus(ui->groupConnectedController->isChecked());

+ ui->controllerFrame->SetPlayerInput(player_index, buttons_param, analogs_param);

+ if (enable_all || npad_style_set.fullkey == 1) {

+ ui->controllerFrame->SetControllerType(

+ GetControllerTypeFromIndex(ui->comboControllerType->currentIndex()));

+ QPushButton* button, std::size_t button_id,

+ std::function<void(const Common::ParamPackage&)> new_input_setter,

+ if (type == InputCommon::Polling::DeviceType::Button) {

+ ui->controllerFrame->BeginMappingButton(button_id);

+ } else if (type == InputCommon::Polling::DeviceType::AnalogPreferred) {

+ ui->controllerFrame->BeginMappingAnalog(button_id);

+ }

+

+ ui->controllerFrame->EndMapping();

+ void HandleClick(QPushButton* button, std::size_t button_id,

+ <item>

+ <widget class="PlayerControlPreview" name="controllerFrame">

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Expanding" vsizetype="Expanding">

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="font">

+ <font>

+ <weight>75</weight>

+ <bold>true</bold>

+ </font>

+ </property>

+ <property name="styleSheet">

+ <string notr="true">image: url(:/controller/pro);</string>

+ </property>

+ <layout class="QVBoxLayout" name="verticalLayout_4">

+ <property name="leftMargin">

+ <number>0</number>

+ </property>

+ <property name="topMargin">

+ <number>0</number>

+ </property>

+ <property name="rightMargin">

+ <number>0</number>

+ </property>

+ <property name="bottomMargin">

+ <number>0</number>

+ </property>

+ </layout>

+ </widget>

+ </item>

+ <customwidgets>

+ <customwidget>

+ <class>PlayerControlPreview</class>

+ <extends>QFrame</extends>

+ <header>yuzu/configuration/configure_input_player_widget.h</header>

+ <container>1</container>

+ </customwidget>

+ </customwidgets>

+// Copyright 2020 yuzu Emulator Project

+// Licensed under GPLv2 or any later version

+// Refer to the license.txt file included.

+

+#include <algorithm>

+#include <QMenu>

+#include <QPainter>

+#include <QTimer>

+#include "yuzu/configuration/configure_input_player_widget.h"

+

+PlayerControlPreview::PlayerControlPreview(QWidget* parent) : QFrame(parent) {

+ UpdateColors();

+ QTimer* timer = new QTimer(this);

+ connect(timer, &QTimer::timeout, this, QOverload<>::of(&PlayerControlPreview::UpdateInput));

+

+ // refresh at 60hz

+ timer->start(16);

+}

+

+PlayerControlPreview::~PlayerControlPreview() = default;

+

+void PlayerControlPreview::SetPlayerInput(std::size_t index, const ButtonParam& buttons_param,

+ const AnalogParam& analogs_param) {

+ player_index = index;

+ Settings::ButtonsRaw buttonss;

+ Settings::AnalogsRaw analogs;

+ std::transform(buttons_param.begin(), buttons_param.end(), buttonss.begin(),

+ [](const Common::ParamPackage& param) { return param.Serialize(); });

+ std::transform(analogs_param.begin(), analogs_param.end(), analogs.begin(),

+ [](const Common::ParamPackage& param) { return param.Serialize(); });

+

+ std::transform(buttonss.begin() + Settings::NativeButton::BUTTON_HID_BEGIN,

+ buttonss.begin() + Settings::NativeButton::BUTTON_NS_END, buttons.begin(),

+ Input::CreateDevice<Input::ButtonDevice>);

+ std::transform(analogs.begin() + Settings::NativeAnalog::STICK_HID_BEGIN,

+ analogs.begin() + Settings::NativeAnalog::STICK_HID_END, sticks.begin(),

+ Input::CreateDevice<Input::AnalogDevice>);

+ UpdateColors();

+}

+void PlayerControlPreview::SetPlayerInputRaw(std::size_t index, const Settings::ButtonsRaw buttons_,

+ Settings::AnalogsRaw analogs_) {

+ player_index = index;

+ std::transform(buttons_.begin() + Settings::NativeButton::BUTTON_HID_BEGIN,

+ buttons_.begin() + Settings::NativeButton::BUTTON_NS_END, buttons.begin(),

+ Input::CreateDevice<Input::ButtonDevice>);

+ std::transform(analogs_.begin() + Settings::NativeAnalog::STICK_HID_BEGIN,

+ analogs_.begin() + Settings::NativeAnalog::STICK_HID_END, sticks.begin(),

+ Input::CreateDevice<Input::AnalogDevice>);

+ UpdateColors();

+}

+

+PlayerControlPreview::LedPattern PlayerControlPreview::GetColorPattern(std::size_t index,

+ bool player_on) {

+ if (!player_on) {

+ return {0, 0, 0, 0};

+ }

+

+ switch (index) {

+ case 0:

+ return {1, 0, 0, 0};

+ case 1:

+ return {1, 1, 0, 0};

+ case 2:

+ return {1, 1, 1, 0};

+ case 3:

+ return {1, 1, 1, 1};

+ case 4:

+ return {1, 0, 0, 1};

+ case 5:

+ return {1, 0, 1, 0};

+ case 6:

+ return {1, 0, 1, 1};

+ case 7:

+ return {0, 1, 1, 0};

+ default:

+ return {0, 0, 0, 0};

+ }

+}

+

+void PlayerControlPreview::SetConnectedStatus(bool checked) {

+ LedPattern led_pattern = GetColorPattern(player_index, checked);

+

+ led_color[0] = led_pattern.position1 ? colors.led_on : colors.led_off;

+ led_color[1] = led_pattern.position2 ? colors.led_on : colors.led_off;

+ led_color[2] = led_pattern.position3 ? colors.led_on : colors.led_off;

+ led_color[3] = led_pattern.position4 ? colors.led_on : colors.led_off;

+}

+

+void PlayerControlPreview::SetControllerType(const Settings::ControllerType type) {

+ controller_type = type;

+ UpdateColors();

+}

+

+void PlayerControlPreview::BeginMappingButton(std::size_t index) {

+ button_mapping_index = index;

+ mapping_active = true;

+}

+

+void PlayerControlPreview::BeginMappingAnalog(std::size_t index) {

+ button_mapping_index = Settings::NativeButton::LStick + index;

+ analog_mapping_index = index;

+ mapping_active = true;

+}

+

+void PlayerControlPreview::EndMapping() {

+ button_mapping_index = Settings::NativeButton::BUTTON_NS_END;

+ analog_mapping_index = Settings::NativeAnalog::NumAnalogs;

+ mapping_active = false;

+ blink_counter = 0;

+}

+

+void PlayerControlPreview::UpdateColors() {

+ if (QIcon::themeName().contains(QStringLiteral("dark")) ||

+ QIcon::themeName().contains(QStringLiteral("midnight"))) {

+ colors.primary = QColor(204, 204, 204);

+ colors.button = QColor(35, 38, 41);

+ colors.button2 = QColor(26, 27, 30);

+ colors.slider_arrow = QColor(14, 15, 18);

+ colors.font2 = QColor(255, 255, 255);

+ colors.indicator = QColor(170, 238, 255);

+ colors.deadzone = QColor(204, 136, 136);

+ colors.slider_button = colors.button;

+ }

+

+ if (QIcon::themeName().contains(QStringLiteral("dark"))) {

+ colors.outline = QColor(160, 160, 160);

+ } else if (QIcon::themeName().contains(QStringLiteral("midnight"))) {

+ colors.outline = QColor(145, 145, 145);

+ } else {

+ colors.outline = QColor(0, 0, 0);

+ colors.primary = QColor(225, 225, 225);

+ colors.button = QColor(109, 111, 114);

+ colors.button2 = QColor(109, 111, 114);

+ colors.button2 = QColor(77, 80, 84);

+ colors.slider_arrow = QColor(65, 68, 73);

+ colors.font2 = QColor(0, 0, 0);

+ colors.indicator = QColor(0, 0, 200);

+ colors.deadzone = QColor(170, 0, 0);

+ colors.slider_button = QColor(153, 149, 149);

+ }

+

+ // Constant colors

+ colors.highlight = QColor(170, 0, 0);

+ colors.highlight2 = QColor(119, 0, 0);

+ colors.slider = QColor(103, 106, 110);

+ colors.transparent = QColor(0, 0, 0, 0);

+ colors.font = QColor(255, 255, 255);

+ colors.led_on = QColor(255, 255, 0);

+ colors.led_off = QColor(170, 238, 255);

+

+ colors.left = colors.primary;

+ colors.right = colors.primary;

+ // Possible alternative to set colors from settings

+ // colors.left = QColor(Settings::values.players.GetValue()[player_index].body_color_left);

+ // colors.right = QColor(Settings::values.players.GetValue()[player_index].body_color_right);

+}

+

+void PlayerControlPreview::UpdateInput() {

+ bool input_changed = false;

+ const auto& button_state = buttons;

+ for (std::size_t index = 0; index < button_values.size(); ++index) {

+ bool value = false;

+ if (index < Settings::NativeButton::BUTTON_NS_END) {

+ value = button_state[index]->GetStatus();

+ }

+ bool blink = mapping_active && index == button_mapping_index;

+ if (analog_mapping_index == Settings::NativeAnalog::NUM_STICKS_HID) {

+ blink &= blink_counter > 25;

+ }

+ if (button_values[index] != value || blink) {

+ input_changed = true;

+ }

+ button_values[index] = value || blink;

+ }

+

+ const auto& analog_state = sticks;

+ for (std::size_t index = 0; index < axis_values.size(); ++index) {

+ const auto [stick_x_f, stick_y_f] = analog_state[index]->GetStatus();

+ const auto [stick_x_rf, stick_y_rf] = analog_state[index]->GetRawStatus();

+

+ if (static_cast<int>(stick_x_rf * 45) !=

+ static_cast<int>(axis_values[index].raw_value.x() * 45) ||

+ static_cast<int>(-stick_y_rf * 45) !=

+ static_cast<int>(axis_values[index].raw_value.y() * 45)) {

+ input_changed = true;

+ }

+

+ axis_values[index].properties = analog_state[index]->GetAnalogProperties();

+ axis_values[index].value = QPointF(stick_x_f, -stick_y_f);

+ axis_values[index].raw_value = QPointF(stick_x_rf, -stick_y_rf);

+

+ const bool blink_analog = mapping_active && index == analog_mapping_index;

+ if (blink_analog) {

+ input_changed = true;

+ axis_values[index].value =

+ QPointF(blink_counter < 25 ? -blink_counter / 25.0f : 0,

+ blink_counter > 25 ? -(blink_counter - 25) / 25.0f : 0);

+ }

+ }

+

+ if (input_changed) {

+ update();

+ }

+

+ if (mapping_active) {

+ blink_counter = (blink_counter + 1) % 50;

+ }

+}

+

+void PlayerControlPreview::paintEvent(QPaintEvent* event) {

+ QFrame::paintEvent(event);

+ QPainter p(this);

+ p.setRenderHint(QPainter::Antialiasing);

+ const QPointF center = rect().center();

+

+ switch (controller_type) {

+ case Settings::ControllerType::Handheld:

+ DrawHandheldController(p, center);

+ break;

+ case Settings::ControllerType::DualJoyconDetached:

+ DrawDualController(p, center);

+ break;

+ case Settings::ControllerType::LeftJoycon:

+ DrawLeftController(p, center);

+ break;

+ case Settings::ControllerType::RightJoycon:

+ DrawRightController(p, center);

+ break;

+ case Settings::ControllerType::ProController:

+ default:

+ DrawProController(p, center);

+ break;

+ }

+}

+

+void PlayerControlPreview::DrawLeftController(QPainter& p, const QPointF center) {

+ {

+ using namespace Settings::NativeButton;

+

+ // Sideview left joystick

+ DrawJoystickSideview(p, center + QPoint(142, -69),

+ -axis_values[Settings::NativeAnalog::LStick].value.y(), 1.15f,

+ button_values[LStick]);

+

+ // Topview D-pad buttons

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawRoundButton(p, center + QPoint(-163, -21), button_values[DLeft], 11, 5, Direction::Up);

+ DrawRoundButton(p, center + QPoint(-117, -21), button_values[DRight], 11, 5, Direction::Up);

+

+ // Topview left joystick

+ DrawJoystickSideview(p, center + QPointF(-140.5f, -28),

+ -axis_values[Settings::NativeAnalog::LStick].value.x() + 15.0f, 1.15f,

+ button_values[LStick]);

+

+ // Topview minus button

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawRoundButton(p, center + QPoint(-111, -22), button_values[Minus], 8, 4, Direction::Up,

+ 1);

+

+ // Left trigger

+ DrawLeftTriggers(p, center, button_values[L]);

+ DrawRoundButton(p, center + QPoint(151, -146), button_values[L], 8, 4, Direction::Down);

+ DrawLeftZTriggers(p, center, button_values[ZL]);

+

+ // Sideview D-pad buttons

+ DrawRoundButton(p, center + QPoint(135, 14), button_values[DLeft], 5, 11, Direction::Right);

+ DrawRoundButton(p, center + QPoint(135, 36), button_values[DDown], 5, 11, Direction::Right);

+ DrawRoundButton(p, center + QPoint(135, -10), button_values[DUp], 5, 11, Direction::Right);

+ DrawRoundButton(p, center + QPoint(135, 14), button_values[DRight], 5, 11,

+ Direction::Right);

+ DrawRoundButton(p, center + QPoint(135, 71), button_values[Screenshot], 3, 8,

+ Direction::Right, 1);

+

+ // Sideview minus button

+ DrawRoundButton(p, center + QPoint(135, -118), button_values[Minus], 4, 2.66f,

+ Direction::Right, 1);

+

+ // Sideview SL and SR buttons

+ button_color = colors.slider_button;

+ DrawRoundButton(p, center + QPoint(59, 52), button_values[SR], 5, 12, Direction::Left);

+ DrawRoundButton(p, center + QPoint(59, -69), button_values[SL], 5, 12, Direction::Left);

+

+ DrawLeftBody(p, center);

+

+ // Left trigger top view

+ DrawLeftTriggersTopView(p, center, button_values[L]);

+ DrawLeftZTriggersTopView(p, center, button_values[ZL]);

+ }

+

+ {

+ // Draw joysticks

+ using namespace Settings::NativeAnalog;

+ DrawJoystick(p, center + QPointF(9, -69) + (axis_values[LStick].value * 8), 1.8f,

+ button_values[Settings::NativeButton::LStick]);

+ DrawRawJoystick(p, center + QPointF(-140, 90), axis_values[LStick].raw_value,

+ axis_values[LStick].properties);

+ }

+

+ using namespace Settings::NativeButton;

+

+ // D-pad constants

+ const QPointF dpad_center = center + QPoint(9, 14);

+ constexpr int dpad_distance = 23;

+ constexpr int dpad_radius = 11;

+ constexpr float dpad_arrow_size = 1.2f;

+

+ // D-pad buttons

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawCircleButton(p, dpad_center + QPoint(dpad_distance, 0), button_values[DRight], dpad_radius);

+ DrawCircleButton(p, dpad_center + QPoint(0, dpad_distance), button_values[DDown], dpad_radius);

+ DrawCircleButton(p, dpad_center + QPoint(0, -dpad_distance), button_values[DUp], dpad_radius);

+ DrawCircleButton(p, dpad_center + QPoint(-dpad_distance, 0), button_values[DLeft], dpad_radius);

+

+ // D-pad arrows

+ p.setPen(colors.font2);

+ p.setBrush(colors.font2);

+ DrawArrow(p, dpad_center + QPoint(dpad_distance, 0), Direction::Right, dpad_arrow_size);

+ DrawArrow(p, dpad_center + QPoint(0, dpad_distance), Direction::Down, dpad_arrow_size);

+ DrawArrow(p, dpad_center + QPoint(0, -dpad_distance), Direction::Up, dpad_arrow_size);

+ DrawArrow(p, dpad_center + QPoint(-dpad_distance, 0), Direction::Left, dpad_arrow_size);

+

+ // SR and SL buttons

+ p.setPen(colors.outline);

+ button_color = colors.slider_button;

+ DrawRoundButton(p, center + QPoint(155, 52), button_values[SR], 5.2f, 12, Direction::None, 4);

+ DrawRoundButton(p, center + QPoint(155, -69), button_values[SL], 5.2f, 12, Direction::None, 4);

+

+ // SR and SL text

+ p.setPen(colors.transparent);

+ p.setBrush(colors.font2);

+ DrawSymbol(p, center + QPointF(155, 52), Symbol::SR, 1.0f);

+ DrawSymbol(p, center + QPointF(155, -69), Symbol::SL, 1.0f);

+

+ // Minus button

+ button_color = colors.button;

+ DrawMinusButton(p, center + QPoint(39, -118), button_values[Minus], 16);

+

+ // Screenshot button

+ DrawRoundButton(p, center + QPoint(26, 71), button_values[Screenshot], 8, 8);

+ p.setPen(colors.font2);

+ p.setBrush(colors.font2);

+ DrawCircle(p, center + QPoint(26, 71), 5);

+}

+

+void PlayerControlPreview::DrawRightController(QPainter& p, const QPointF center) {

+ {

+ using namespace Settings::NativeButton;

+

+ // Sideview right joystick

+ DrawJoystickSideview(p, center + QPoint(173 - 315, 11),

+ axis_values[Settings::NativeAnalog::RStick].value.y() + 10.0f, 1.15f,

+ button_values[Settings::NativeButton::RStick]);

+

+ // Topview face buttons

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawRoundButton(p, center + QPoint(163, -21), button_values[A], 11, 5, Direction::Up);

+ DrawRoundButton(p, center + QPoint(117, -21), button_values[Y], 11, 5, Direction::Up);

+

+ // Topview right joystick

+ DrawJoystickSideview(p, center + QPointF(140, -28),

+ -axis_values[Settings::NativeAnalog::RStick].value.x() + 15.0f, 1.15f,

+ button_values[RStick]);

+

+ // Topview plus button

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawRoundButton(p, center + QPoint(111, -22), button_values[Plus], 8, 4, Direction::Up, 1);

+ DrawRoundButton(p, center + QPoint(111, -22), button_values[Plus], 2.66f, 4, Direction::Up,

+ 1);

+

+ // Right trigger

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawRightTriggers(p, center, button_values[R]);

+ DrawRoundButton(p, center + QPoint(-151, -146), button_values[R], 8, 4, Direction::Down);

+ DrawRightZTriggers(p, center, button_values[ZR]);

+

+ // Sideview face buttons

+ DrawRoundButton(p, center + QPoint(-135, -73), button_values[A], 5, 11, Direction::Left);

+ DrawRoundButton(p, center + QPoint(-135, -50), button_values[B], 5, 11, Direction::Left);

+ DrawRoundButton(p, center + QPoint(-135, -95), button_values[X], 5, 11, Direction::Left);

+ DrawRoundButton(p, center + QPoint(-135, -73), button_values[Y], 5, 11, Direction::Left);

+

+ // Sideview home and plus button

+ DrawRoundButton(p, center + QPoint(-135, 66), button_values[Home], 3, 12, Direction::Left);

+ DrawRoundButton(p, center + QPoint(-135, -118), button_values[Plus], 4, 8, Direction::Left,

+ 1);

+ DrawRoundButton(p, center + QPoint(-135, -118), button_values[Plus], 4, 2.66f,

+ Direction::Left, 1);

+

+ // Sideview SL and SR buttons

+ button_color = colors.slider_button;

+ DrawRoundButton(p, center + QPoint(-59, 52), button_values[SL], 5, 11, Direction::Right);

+ DrawRoundButton(p, center + QPoint(-59, -69), button_values[SR], 5, 11, Direction::Right);

+

+ DrawRightBody(p, center);

+

+ // Right trigger top view

+ DrawRightTriggersTopView(p, center, button_values[R]);

+ DrawRightZTriggersTopView(p, center, button_values[ZR]);

+ }

+

+ {

+ // Draw joysticks

+ using namespace Settings::NativeAnalog;

+ DrawJoystick(p, center + QPointF(-9, 11) + (axis_values[RStick].value * 8), 1.8f,

+ button_values[Settings::NativeButton::RStick]);

+ DrawRawJoystick(p, center + QPointF(140, 90), axis_values[RStick].raw_value,

+ axis_values[RStick].properties);

+ }

+

+ using namespace Settings::NativeButton;

+

+ // Face buttons constants

+ const QPointF face_center = center + QPoint(-9, -73);

+ constexpr int face_distance = 23;

+ constexpr int face_radius = 11;

+ constexpr float text_size = 1.1f;

+

+ // Face buttons

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawCircleButton(p, face_center + QPoint(face_distance, 0), button_values[A], face_radius);

+ DrawCircleButton(p, face_center + QPoint(0, face_distance), button_values[B], face_radius);

+ DrawCircleButton(p, face_center + QPoint(0, -face_distance), button_values[X], face_radius);

+ DrawCircleButton(p, face_center + QPoint(-face_distance, 0), button_values[Y], face_radius);

+

+ // Face buttons text

+ p.setPen(colors.transparent);

+ p.setBrush(colors.font);

+ DrawSymbol(p, face_center + QPoint(face_distance, 0), Symbol::A, text_size);

+ DrawSymbol(p, face_center + QPoint(0, face_distance), Symbol::B, text_size);

+ DrawSymbol(p, face_center + QPoint(0, -face_distance), Symbol::X, text_size);

+ DrawSymbol(p, face_center + QPoint(-face_distance, 1), Symbol::Y, text_size);

+

+ // SR and SL buttons

+ p.setPen(colors.outline);

+ button_color = colors.slider_button;

+ DrawRoundButton(p, center + QPoint(-155, 52), button_values[SL], 5, 12, Direction::None, 4.0f);

+ DrawRoundButton(p, center + QPoint(-155, -69), button_values[SR], 5, 12, Direction::None, 4.0f);

+

+ // SR and SL text

+ p.setPen(colors.transparent);

+ p.setBrush(colors.font2);

+ p.rotate(-180);

+ DrawSymbol(p, QPointF(-center.x(), -center.y()) + QPointF(155, 69), Symbol::SR, 1.0f);

+ DrawSymbol(p, QPointF(-center.x(), -center.y()) + QPointF(155, -52), Symbol::SL, 1.0f);

+ p.rotate(180);

+

+ // Plus Button

+ DrawPlusButton(p, center + QPoint(-40, -118), button_values[Plus], 16);

+

+ // Home Button

+ p.setPen(colors.outline);

+ button_color = colors.slider_button;

+ DrawCircleButton(p, center + QPoint(-26, 66), button_values[Home], 12);

+ button_color = colors.button;

+ DrawCircleButton(p, center + QPoint(-26, 66), button_values[Home], 9);

+ p.setPen(colors.transparent);

+ p.setBrush(colors.font2);

+ DrawSymbol(p, center + QPoint(-26, 66), Symbol::House, 5);

+}

+

+void PlayerControlPreview::DrawDualController(QPainter& p, const QPointF center) {

+ {

+ using namespace Settings::NativeButton;

+

+ // Left/Right trigger

+ DrawDualTriggers(p, center, button_values[L], button_values[R]);

+

+ // Topview face buttons

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawRoundButton(p, center + QPoint(200, -71), button_values[A], 10, 5, Direction::Up);

+ DrawRoundButton(p, center + QPoint(160, -71), button_values[Y], 10, 5, Direction::Up);

+

+ // Topview right joystick

+ DrawJoystickSideview(p, center + QPointF(180, -78),

+ -axis_values[Settings::NativeAnalog::RStick].value.x() + 15.0f, 1,

+ button_values[RStick]);

+

+ // Topview plus button

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawRoundButton(p, center + QPoint(154, -72), button_values[Plus], 7, 4, Direction::Up, 1);

+ DrawRoundButton(p, center + QPoint(154, -72), button_values[Plus], 2.33f, 4, Direction::Up,

+ 1);

+

+ // Topview D-pad buttons

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawRoundButton(p, center + QPoint(-200, -71), button_values[DLeft], 10, 5, Direction::Up);

+ DrawRoundButton(p, center + QPoint(-160, -71), button_values[DRight], 10, 5, Direction::Up);

+

+ // Topview left joystick

+ DrawJoystickSideview(p, center + QPointF(-180.5f, -78),

+ -axis_values[Settings::NativeAnalog::LStick].value.x() + 15.0f, 1,

+ button_values[LStick]);

+

+ // Topview minus button

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawRoundButton(p, center + QPoint(-154, -72), button_values[Minus], 7, 4, Direction::Up,

+ 1);

+

+ DrawDualBody(p, center);

+

+ // Right trigger top view

+ DrawDualTriggersTopView(p, center, button_values[L], button_values[R]);

+ DrawDualZTriggersTopView(p, center, button_values[ZL], button_values[ZR]);

+ }

+

+ {

+ // Draw joysticks

+ using namespace Settings::NativeAnalog;

+ DrawJoystick(p, center + QPointF(-65, -65) + (axis_values[LStick].value * 7), 1.62f,

+ button_values[Settings::NativeButton::LStick]);

+ DrawJoystick(p, center + QPointF(65, 12) + (axis_values[RStick].value * 7), 1.62f,

+ button_values[Settings::NativeButton::RStick]);

+ DrawRawJoystick(p, center + QPointF(-180, 90), axis_values[LStick].raw_value,

+ axis_values[LStick].properties);

+ DrawRawJoystick(p, center + QPointF(180, 90), axis_values[RStick].raw_value,

+ axis_values[RStick].properties);

+ }

+

+ using namespace Settings::NativeButton;

+

+ // Face buttons constants

+ const QPointF face_center = center + QPoint(65, -65);

+ constexpr int face_distance = 20;

+ constexpr int face_radius = 10;

+ constexpr float text_size = 1.0f;

+

+ // Face buttons

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawCircleButton(p, face_center + QPoint(face_distance, 0), button_values[A], face_radius);

+ DrawCircleButton(p, face_center + QPoint(0, face_distance), button_values[B], face_radius);

+ DrawCircleButton(p, face_center + QPoint(0, -face_distance), button_values[X], face_radius);

+ DrawCircleButton(p, face_center + QPoint(-face_distance, 0), button_values[Y], face_radius);

+

+ // Face buttons text

+ p.setPen(colors.transparent);

+ p.setBrush(colors.font);

+ DrawSymbol(p, face_center + QPoint(face_distance, 0), Symbol::A, text_size);

+ DrawSymbol(p, face_center + QPoint(0, face_distance), Symbol::B, text_size);

+ DrawSymbol(p, face_center + QPoint(0, -face_distance), Symbol::X, text_size);

+ DrawSymbol(p, face_center + QPoint(-face_distance, 1), Symbol::Y, text_size);

+

+ // D-pad constants

+ const QPointF dpad_center = center + QPoint(-65, 12);

+ constexpr int dpad_distance = 20;

+ constexpr int dpad_radius = 10;

+ constexpr float dpad_arrow_size = 1.1f;

+

+ // D-pad buttons

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawCircleButton(p, dpad_center + QPoint(dpad_distance, 0), button_values[DRight], dpad_radius);

+ DrawCircleButton(p, dpad_center + QPoint(0, dpad_distance), button_values[DDown], dpad_radius);

+ DrawCircleButton(p, dpad_center + QPoint(0, -dpad_distance), button_values[DUp], dpad_radius);

+ DrawCircleButton(p, dpad_center + QPoint(-dpad_distance, 0), button_values[DLeft], dpad_radius);

+

+ // D-pad arrows

+ p.setPen(colors.font2);

+ p.setBrush(colors.font2);

+ DrawArrow(p, dpad_center + QPoint(dpad_distance, 0), Direction::Right, dpad_arrow_size);

+ DrawArrow(p, dpad_center + QPoint(0, dpad_distance), Direction::Down, dpad_arrow_size);

+ DrawArrow(p, dpad_center + QPoint(0, -dpad_distance), Direction::Up, dpad_arrow_size);

+ DrawArrow(p, dpad_center + QPoint(-dpad_distance, 0), Direction::Left, dpad_arrow_size);

+

+ // Minus and Plus button

+ button_color = colors.button;

+ DrawMinusButton(p, center + QPoint(-39, -106), button_values[Minus], 14);

+ DrawPlusButton(p, center + QPoint(39, -106), button_values[Plus], 14);

+

+ // Screenshot button

+ p.setPen(colors.outline);

+ DrawRoundButton(p, center + QPoint(-52, 63), button_values[Screenshot], 8, 8);

+ p.setPen(colors.font2);

+ p.setBrush(colors.font2);

+ DrawCircle(p, center + QPoint(-52, 63), 5);

+

+ // Home Button

+ p.setPen(colors.outline);

+ button_color = colors.slider_button;

+ DrawCircleButton(p, center + QPoint(50, 60), button_values[Home], 11);

+ button_color = colors.button;

+ DrawCircleButton(p, center + QPoint(50, 60), button_values[Home], 8.5f);

+ p.setPen(colors.transparent);

+ p.setBrush(colors.font2);

+ DrawSymbol(p, center + QPoint(50, 60), Symbol::House, 4.2f);

+}

+

+void PlayerControlPreview::DrawHandheldController(QPainter& p, const QPointF center) {

+ DrawHandheldTriggers(p, center, button_values[Settings::NativeButton::L],

+ button_values[Settings::NativeButton::R]);

+ DrawHandheldBody(p, center);

+ {

+ // Draw joysticks

+ using namespace Settings::NativeAnalog;

+ DrawJoystick(p, center + QPointF(-171, -41) + (axis_values[LStick].value * 4), 1.0f,

+ button_values[Settings::NativeButton::LStick]);

+ DrawJoystick(p, center + QPointF(171, 8) + (axis_values[RStick].value * 4), 1.0f,

+ button_values[Settings::NativeButton::RStick]);

+ DrawRawJoystick(p, center + QPointF(-50, 0), axis_values[LStick].raw_value,

+ axis_values[LStick].properties);

+ DrawRawJoystick(p, center + QPointF(50, 0), axis_values[RStick].raw_value,

+ axis_values[RStick].properties);

+ }

+

+ using namespace Settings::NativeButton;

+

+ // Face buttons constants

+ const QPointF face_center = center + QPoint(171, -41);

+ constexpr float face_distance = 12.8f;

+ constexpr float face_radius = 6.4f;

+ constexpr float text_size = 0.6f;

+

+ // Face buttons

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawCircleButton(p, face_center + QPoint(face_distance, 0), button_values[A], face_radius);

+ DrawCircleButton(p, face_center + QPoint(0, face_distance), button_values[B], face_radius);

+ DrawCircleButton(p, face_center + QPoint(0, -face_distance), button_values[X], face_radius);

+ DrawCircleButton(p, face_center + QPoint(-face_distance, 0), button_values[Y], face_radius);

+

+ // Face buttons text

+ p.setPen(colors.transparent);

+ p.setBrush(colors.font);

+ DrawSymbol(p, face_center + QPoint(face_distance, 0), Symbol::A, text_size);

+ DrawSymbol(p, face_center + QPoint(0, face_distance), Symbol::B, text_size);

+ DrawSymbol(p, face_center + QPoint(0, -face_distance), Symbol::X, text_size);

+ DrawSymbol(p, face_center + QPoint(-face_distance, 1), Symbol::Y, text_size);

+

+ // D-pad constants

+ const QPointF dpad_center = center + QPoint(-171, 8);

+ constexpr float dpad_distance = 12.8f;

+ constexpr float dpad_radius = 6.4f;

+ constexpr float dpad_arrow_size = 0.68f;

+

+ // D-pad buttons

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawCircleButton(p, dpad_center + QPoint(dpad_distance, 0), button_values[DRight], dpad_radius);

+ DrawCircleButton(p, dpad_center + QPoint(0, dpad_distance), button_values[DDown], dpad_radius);

+ DrawCircleButton(p, dpad_center + QPoint(0, -dpad_distance), button_values[DUp], dpad_radius);

+ DrawCircleButton(p, dpad_center + QPoint(-dpad_distance, 0), button_values[DLeft], dpad_radius);

+

+ // D-pad arrows

+ p.setPen(colors.font2);

+ p.setBrush(colors.font2);

+ DrawArrow(p, dpad_center + QPoint(dpad_distance, 0), Direction::Right, dpad_arrow_size);

+ DrawArrow(p, dpad_center + QPoint(0, dpad_distance), Direction::Down, dpad_arrow_size);

+ DrawArrow(p, dpad_center + QPoint(0, -dpad_distance), Direction::Up, dpad_arrow_size);

+ DrawArrow(p, dpad_center + QPoint(-dpad_distance, 0), Direction::Left, dpad_arrow_size);

+

+ // ZL and ZR buttons

+ p.setPen(colors.outline);

+ DrawTriggerButton(p, center + QPoint(-210, -130), Direction::Left, button_values[ZL]);

+ DrawTriggerButton(p, center + QPoint(210, -130), Direction::Right, button_values[ZR]);

+ p.setPen(colors.transparent);

+ p.setBrush(colors.font);

+ DrawSymbol(p, center + QPoint(-210, -130), Symbol::ZL, 1.5f);

+ DrawSymbol(p, center + QPoint(210, -130), Symbol::ZR, 1.5f);

+

+ // Minus and Plus button

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawMinusButton(p, center + QPoint(-155, -67), button_values[Minus], 8);

+ DrawPlusButton(p, center + QPoint(155, -67), button_values[Plus], 8);

+

+ // Screenshot button

+ p.setPen(colors.outline);

+ DrawRoundButton(p, center + QPoint(-162, 39), button_values[Screenshot], 5, 5);

+ p.setPen(colors.font2);

+ p.setBrush(colors.font2);

+ DrawCircle(p, center + QPoint(-162, 39), 3);

+

+ // Home Button

+ p.setPen(colors.outline);

+ button_color = colors.slider_button;

+ DrawCircleButton(p, center + QPoint(161, 37), button_values[Home], 7);

+ button_color = colors.button;

+ DrawCircleButton(p, center + QPoint(161, 37), button_values[Home], 5);

+ p.setPen(colors.transparent);

+ p.setBrush(colors.font2);

+ DrawSymbol(p, center + QPoint(161, 37), Symbol::House, 2.75f);

+}

+

+void PlayerControlPreview::DrawProController(QPainter& p, const QPointF center) {

+ DrawProTriggers(p, center, button_values[Settings::NativeButton::L],

+ button_values[Settings::NativeButton::R]);

+ DrawProBody(p, center);

+ {

+ // Draw joysticks

+ using namespace Settings::NativeAnalog;

+ DrawProJoystick(p, center + QPointF(-111, -55) + (axis_values[LStick].value * 11),

+ button_values[Settings::NativeButton::LStick]);

+ DrawProJoystick(p, center + QPointF(51, 0) + (axis_values[RStick].value * 11),

+ button_values[Settings::NativeButton::RStick]);

+ DrawRawJoystick(p, center + QPointF(-50, 105), axis_values[LStick].raw_value,

+ axis_values[LStick].properties);

+ DrawRawJoystick(p, center + QPointF(50, 105), axis_values[RStick].raw_value,

+ axis_values[RStick].properties);

+ }

+

+ using namespace Settings::NativeButton;

+

+ // Face buttons constants

+ const QPointF face_center = center + QPoint(105, -56);

+ constexpr int face_distance = 31;

+ constexpr int face_radius = 15;

+ constexpr float text_size = 1.5f;

+

+ // Face buttons

+ p.setPen(colors.outline);

+ button_color = colors.button;

+ DrawCircleButton(p, face_center + QPoint(face_distance, 0), button_values[A], face_radius);

+ DrawCircleButton(p, face_center + QPoint(0, face_distance), button_values[B], face_radius);

+ DrawCircleButton(p, face_center + QPoint(0, -face_distance), button_values[X], face_radius);

+ DrawCircleButton(p, face_center + QPoint(-face_distance, 0), button_values[Y], face_radius);

+

+ // Face buttons text

+ p.setPen(colors.transparent);

+ p.setBrush(colors.font);

+ DrawSymbol(p, face_center + QPoint(face_distance, 0), Symbol::A, text_size);

+ DrawSymbol(p, face_center + QPoint(0, face_distance), Symbol::B, text_size);

+ DrawSymbol(p, face_center + QPoint(0, -face_distance), Symbol::X, text_size);

+ DrawSymbol(p, face_center + QPoint(-face_distance, 1), Symbol::Y, text_size);

+

+ // D-pad buttons

+ const QPointF dpad_postion = center + QPoint(-61, 0);

+ DrawArrowButton(p, dpad_postion, Direction::Up, button_values[DUp]);

+ DrawArrowButton(p, dpad_postion, Direction::Left, button_values[DLeft]);

+ DrawArrowButton(p, dpad_postion, Direction::Right, button_values[DRight]);

+ DrawArrowButton(p, dpad_postion, Direction::Down, button_values[DDown]);

+ DrawArrowButtonOutline(p, dpad_postion);

+

+ // ZL and ZR buttons

+ p.setPen(colors.outline);

+ DrawTriggerButton(p, center + QPoint(-210, -130), Direction::Left, button_values[ZL]);

+ DrawTriggerButton(p, center + QPoint(210, -130), Direction::Right, button_values[ZR]);

+ p.setPen(colors.transparent);

+ p.setBrush(colors.font);

+ DrawSymbol(p, center + QPoint(-210, -130), Symbol::ZL, 1.5f);

+ DrawSymbol(p, center + QPoint(210, -130), Symbol::ZR, 1.5f);

+

+ // Minus and Plus buttons

+ p.setPen(colors.outline);

+ DrawCircleButton(p, center + QPoint(-50, -86), button_values[Minus], 9);

+ DrawCircleButton(p, center + QPoint(50, -86), button_values[Plus], 9);

+

+ // Minus and Plus symbols

+ p.setPen(colors.font2);

+ p.setBrush(colors.font2);

+ DrawRectangle(p, center + QPoint(-50, -86), 9, 1.5f);

+ DrawRectangle(p, center + QPoint(50, -86), 9, 1.5f);

+ DrawRectangle(p, center + QPoint(50, -86), 1.5f, 9);

+

+ // Screenshot button

+ p.setPen(colors.outline);

+ DrawRoundButton(p, center + QPoint(-29, -56), button_values[Screenshot], 7, 7);

+ p.setPen(colors.font2);

+ p.setBrush(colors.font2);

+ DrawCircle(p, center + QPoint(-29, -56), 4.5f);

+

+ // Home Button

+ p.setPen(colors.outline);

+ button_color = colors.slider_button;

+ DrawCircleButton(p, center + QPoint(29, -56), button_values[Home], 10.0f);

+ button_color = colors.button;

+ DrawCircleButton(p, center + QPoint(29, -56), button_values[Home], 7.1f);

+ p.setPen(colors.transparent);

+ p.setBrush(colors.font2);

+ DrawSymbol(p, center + QPoint(29, -56), Symbol::House, 3.9f);

+}

+

+void PlayerControlPreview::DrawGCController(QPainter& p, const QPointF center) {

+ DrawGCTriggers(p, center, button_values[Settings::NativeButton::ZL],

+ button_values[Settings::NativeButton::ZR]);

+ DrawGCButtonZ(p, center, button_values[Settings::NativeButton::R]);

+ DrawGCBody(p, center);

+ {

+ // Draw joysticks

+ using namespace Settings::NativeAnalog;

+ DrawGCJoystick(p, center + QPointF(-111, -44) + (axis_values[LStick].value * 10), false);

+ button_color = colors.button2;

+ DrawCircleButton(p, center + QPointF(61, 37) + (axis_values[RStick].value * 9.5f), false,

+ 15);

+ p.setPen(colors.transparent);

+ p.setBrush(colors.font);

+ DrawSymbol(p, center + QPointF(61, 37) + (axis_values[RStick].value * 9.5f), Symbol::C,

+ 1.0f);

+ DrawRawJoystick(p, center + QPointF(-198, -125), axis_values[LStick].raw_value,

+ axis_values[LStick].properties);

+ DrawRawJoystick(p, center + QPointF(198, -125), axis_values[RStick].raw_value,

+ axis_values[RStick].properties);

+ }