/****************************************************************************
** Meta object code from reading C++ file 'qthost.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.9.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../../../../../duckstation/src/duckstation-qt/qthost.h"
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'qthost.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.9.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN9EmuThreadE_t {};
} // unnamed namespace

template <> constexpr inline auto EmuThread::qt_create_metaobjectdata<qt_meta_tag_ZN9EmuThreadE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "EmuThread",
        "errorReported",
        "",
        "title",
        "message",
        "messageConfirmed",
        "statusMessage",
        "debuggerMessageReported",
        "settingsResetToDefault",
        "system",
        "controller",
        "systemStarting",
        "systemStarted",
        "systemStopping",
        "systemDestroyed",
        "systemPaused",
        "systemResumed",
        "systemGameChanged",
        "filename",
        "game_serial",
        "game_title",
        "systemUndoStateAvailabilityChanged",
        "available",
        "timestamp",
        "gameListRefreshed",
        "gameListRowsChanged",
        "QList<int>",
        "rows_changed",
        "onAcquireRenderWindowRequested",
        "std::optional<WindowInfo>",
        "RenderAPI",
        "render_api",
        "fullscreen",
        "exclusive_fullscreen",
        "surfaceless",
        "Error*",
        "error",
        "onResizeRenderWindowRequested",
        "width",
        "height",
        "onReleaseRenderWindowRequested",
        "focusDisplayWidgetRequested",
        "inputProfileLoaded",
        "mouseModeRequested",
        "relative",
        "hide_cursor",
        "fullscreenUIStartedOrStopped",
        "running",
        "achievementsLoginRequested",
        "Achievements::LoginRequestReason",
        "reason",
        "achievementsLoginSuccess",
        "username",
        "points",
        "sc_points",
        "unread_messages",
        "achievementsRefreshed",
        "id",
        "game_info_string",
        "achievementsActiveChanged",
        "active",
        "achievementsHardcoreModeChanged",
        "enabled",
        "achievementsAllProgressRefreshed",
        "mediaCaptureStarted",
        "mediaCaptureStopped",
        "onCreateAuxiliaryRenderWindow",
        "x",
        "y",
        "icon_name",
        "Host::AuxiliaryRenderWindowUserData",
        "userdata",
        "Host::AuxiliaryRenderWindowHandle*",
        "handle",
        "WindowInfo*",
        "wi",
        "onDestroyAuxiliaryRenderWindow",
        "Host::AuxiliaryRenderWindowHandle",
        "QPoint*",
        "pos",
        "QSize*",
        "size",
        "onCoverDownloaderOpenRequested",
        "setDefaultSettings",
        "applySettings",
        "display_osd_messages",
        "reloadGameSettings",
        "reloadInputProfile",
        "reloadCheats",
        "reload_files",
        "reload_enabled_list",
        "verbose",
        "verbose_if_changed",
        "updateEmuFolders",
        "updateControllerSettings",
        "reloadInputSources",
        "reloadInputBindings",
        "reloadInputDevices",
        "closeInputSources",
        "startFullscreenUI",
        "stopFullscreenUI",
        "exitFullscreenUI",
        "refreshAchievementsAllProgress",
        "bootSystem",
        "std::shared_ptr<SystemBootParameters>",
        "params",
        "resumeSystemFromMostRecentState",
        "shutdownSystem",
        "save_state",
        "check_memcard_busy",
        "resetSystem",
        "setSystemPaused",
        "paused",
        "wait_until_paused",
        "changeDisc",
        "new_disc_filename",
        "reset_system",
        "changeDiscFromPlaylist",
        "index",
        "loadState",
        "global",
        "slot",
        "saveState",
        "block_until_done",
        "undoLoadState",
        "setAudioOutputVolume",
        "volume",
        "fast_forward_volume",
        "setAudioOutputMuted",
        "muted",
        "singleStepCPU",
        "dumpRAM",
        "dumpVRAM",
        "dumpSPURAM",
        "saveScreenshot",
        "redrawDisplayWindow",
        "toggleFullscreen",
        "setFullscreen",
        "setSurfaceless",
        "updateDisplayWindow",
        "requestDisplaySize",
        "scale",
        "applyCheat",
        "name",
        "reloadPostProcessingShaders",
        "updatePostProcessingSettings",
        "display",
        "internal",
        "force_reload",
        "clearInputBindStateFromSource",
        "InputBindingKey",
        "key",
        "reloadTextureReplacements",
        "captureGPUFrameDump",
        "startControllerTest",
        "setGPUThreadRunIdle",
        "updateFullscreenUITheme",
        "stopInThread",
        "onDisplayWindowMouseButtonEvent",
        "button",
        "pressed",
        "onDisplayWindowMouseWheelEvent",
        "dx",
        "dy",
        "onDisplayWindowResized",
        "onDisplayWindowKeyEvent",
        "onDisplayWindowTextEntered",
        "text",
        "doBackgroundControllerPoll",
        "runOnEmuThread",
        "std::function<void()>",
        "callback",
        "processAuxiliaryRenderWindowInputEvent",
        "event",
        "param1",
        "param2",
        "param3"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'errorReported'
        QtMocHelpers::SignalData<void(const QString &, const QString &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { QMetaType::QString, 4 },
        }}),
        // Signal 'messageConfirmed'
        QtMocHelpers::SignalData<bool(const QString &, const QString &)>(5, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 3 }, { QMetaType::QString, 4 },
        }}),
        // Signal 'statusMessage'
        QtMocHelpers::SignalData<void(const QString &)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 4 },
        }}),
        // Signal 'debuggerMessageReported'
        QtMocHelpers::SignalData<void(const QString &)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 4 },
        }}),
        // Signal 'settingsResetToDefault'
        QtMocHelpers::SignalData<void(bool, bool)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 9 }, { QMetaType::Bool, 10 },
        }}),
        // Signal 'systemStarting'
        QtMocHelpers::SignalData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'systemStarted'
        QtMocHelpers::SignalData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'systemStopping'
        QtMocHelpers::SignalData<void()>(13, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'systemDestroyed'
        QtMocHelpers::SignalData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'systemPaused'
        QtMocHelpers::SignalData<void()>(15, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'systemResumed'
        QtMocHelpers::SignalData<void()>(16, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'systemGameChanged'
        QtMocHelpers::SignalData<void(const QString &, const QString &, const QString &)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 18 }, { QMetaType::QString, 19 }, { QMetaType::QString, 20 },
        }}),
        // Signal 'systemUndoStateAvailabilityChanged'
        QtMocHelpers::SignalData<void(bool, quint64)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 22 }, { QMetaType::ULongLong, 23 },
        }}),
        // Signal 'gameListRefreshed'
        QtMocHelpers::SignalData<void()>(24, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'gameListRowsChanged'
        QtMocHelpers::SignalData<void(const QList<int> &)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 26, 27 },
        }}),
        // Signal 'onAcquireRenderWindowRequested'
        QtMocHelpers::SignalData<std::optional<WindowInfo>(RenderAPI, bool, bool, bool, Error *)>(28, 2, QMC::AccessPublic, 0x80000000 | 29, {{
            { 0x80000000 | 30, 31 }, { QMetaType::Bool, 32 }, { QMetaType::Bool, 33 }, { QMetaType::Bool, 34 },
            { 0x80000000 | 35, 36 },
        }}),
        // Signal 'onResizeRenderWindowRequested'
        QtMocHelpers::SignalData<void(qint32, qint32)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 38 }, { QMetaType::Int, 39 },
        }}),
        // Signal 'onReleaseRenderWindowRequested'
        QtMocHelpers::SignalData<void()>(40, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'focusDisplayWidgetRequested'
        QtMocHelpers::SignalData<void()>(41, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'inputProfileLoaded'
        QtMocHelpers::SignalData<void()>(42, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'mouseModeRequested'
        QtMocHelpers::SignalData<void(bool, bool)>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 44 }, { QMetaType::Bool, 45 },
        }}),
        // Signal 'fullscreenUIStartedOrStopped'
        QtMocHelpers::SignalData<void(bool)>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 47 },
        }}),
        // Signal 'achievementsLoginRequested'
        QtMocHelpers::SignalData<void(Achievements::LoginRequestReason)>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 49, 50 },
        }}),
        // Signal 'achievementsLoginSuccess'
        QtMocHelpers::SignalData<void(const QString &, quint32, quint32, quint32)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 52 }, { QMetaType::UInt, 53 }, { QMetaType::UInt, 54 }, { QMetaType::UInt, 55 },
        }}),
        // Signal 'achievementsRefreshed'
        QtMocHelpers::SignalData<void(quint32, const QString &)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 57 }, { QMetaType::QString, 58 },
        }}),
        // Signal 'achievementsActiveChanged'
        QtMocHelpers::SignalData<void(bool)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 60 },
        }}),
        // Signal 'achievementsHardcoreModeChanged'
        QtMocHelpers::SignalData<void(bool)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 62 },
        }}),
        // Signal 'achievementsAllProgressRefreshed'
        QtMocHelpers::SignalData<void()>(63, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'mediaCaptureStarted'
        QtMocHelpers::SignalData<void()>(64, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'mediaCaptureStopped'
        QtMocHelpers::SignalData<void()>(65, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'onCreateAuxiliaryRenderWindow'
        QtMocHelpers::SignalData<bool(RenderAPI, qint32, qint32, quint32, quint32, const QString &, const QString &, Host::AuxiliaryRenderWindowUserData, Host::AuxiliaryRenderWindowHandle *, WindowInfo *, Error *)>(66, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 30, 31 }, { QMetaType::Int, 67 }, { QMetaType::Int, 68 }, { QMetaType::UInt, 38 },
            { QMetaType::UInt, 39 }, { QMetaType::QString, 3 }, { QMetaType::QString, 69 }, { 0x80000000 | 70, 71 },
            { 0x80000000 | 72, 73 }, { 0x80000000 | 74, 75 }, { 0x80000000 | 35, 36 },
        }}),
        // Signal 'onDestroyAuxiliaryRenderWindow'
        QtMocHelpers::SignalData<void(Host::AuxiliaryRenderWindowHandle, QPoint *, QSize *)>(76, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 77, 73 }, { 0x80000000 | 78, 79 }, { 0x80000000 | 80, 81 },
        }}),
        // Signal 'onCoverDownloaderOpenRequested'
        QtMocHelpers::SignalData<void()>(82, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setDefaultSettings'
        QtMocHelpers::SlotData<void(bool, bool)>(83, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 9 }, { QMetaType::Bool, 10 },
        }}),
        // Slot 'setDefaultSettings'
        QtMocHelpers::SlotData<void(bool)>(83, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 9 },
        }}),
        // Slot 'setDefaultSettings'
        QtMocHelpers::SlotData<void()>(83, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'applySettings'
        QtMocHelpers::SlotData<void(bool)>(84, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 85 },
        }}),
        // Slot 'applySettings'
        QtMocHelpers::SlotData<void()>(84, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'reloadGameSettings'
        QtMocHelpers::SlotData<void(bool)>(86, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 85 },
        }}),
        // Slot 'reloadGameSettings'
        QtMocHelpers::SlotData<void()>(86, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'reloadInputProfile'
        QtMocHelpers::SlotData<void(bool)>(87, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 85 },
        }}),
        // Slot 'reloadInputProfile'
        QtMocHelpers::SlotData<void()>(87, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'reloadCheats'
        QtMocHelpers::SlotData<void(bool, bool, bool, bool)>(88, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 89 }, { QMetaType::Bool, 90 }, { QMetaType::Bool, 91 }, { QMetaType::Bool, 92 },
        }}),
        // Slot 'updateEmuFolders'
        QtMocHelpers::SlotData<void()>(93, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateControllerSettings'
        QtMocHelpers::SlotData<void()>(94, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'reloadInputSources'
        QtMocHelpers::SlotData<void()>(95, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'reloadInputBindings'
        QtMocHelpers::SlotData<void()>(96, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'reloadInputDevices'
        QtMocHelpers::SlotData<void()>(97, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'closeInputSources'
        QtMocHelpers::SlotData<void()>(98, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'startFullscreenUI'
        QtMocHelpers::SlotData<void()>(99, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'stopFullscreenUI'
        QtMocHelpers::SlotData<void()>(100, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'exitFullscreenUI'
        QtMocHelpers::SlotData<void()>(101, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'refreshAchievementsAllProgress'
        QtMocHelpers::SlotData<void()>(102, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'bootSystem'
        QtMocHelpers::SlotData<void(std::shared_ptr<SystemBootParameters>)>(103, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 104, 105 },
        }}),
        // Slot 'resumeSystemFromMostRecentState'
        QtMocHelpers::SlotData<void()>(106, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'shutdownSystem'
        QtMocHelpers::SlotData<void(bool, bool)>(107, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 108 }, { QMetaType::Bool, 109 },
        }}),
        // Slot 'resetSystem'
        QtMocHelpers::SlotData<void(bool)>(110, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 109 },
        }}),
        // Slot 'setSystemPaused'
        QtMocHelpers::SlotData<void(bool, bool)>(111, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 112 }, { QMetaType::Bool, 113 },
        }}),
        // Slot 'setSystemPaused'
        QtMocHelpers::SlotData<void(bool)>(111, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 112 },
        }}),
        // Slot 'changeDisc'
        QtMocHelpers::SlotData<void(const QString &, bool, bool)>(114, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 115 }, { QMetaType::Bool, 116 }, { QMetaType::Bool, 109 },
        }}),
        // Slot 'changeDiscFromPlaylist'
        QtMocHelpers::SlotData<void(quint32)>(117, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 118 },
        }}),
        // Slot 'loadState'
        QtMocHelpers::SlotData<void(const QString &)>(119, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 18 },
        }}),
        // Slot 'loadState'
        QtMocHelpers::SlotData<void(bool, qint32)>(119, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 120 }, { QMetaType::Int, 121 },
        }}),
        // Slot 'saveState'
        QtMocHelpers::SlotData<void(const QString &, bool)>(122, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 18 }, { QMetaType::Bool, 123 },
        }}),
        // Slot 'saveState'
        QtMocHelpers::SlotData<void(const QString &)>(122, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 18 },
        }}),
        // Slot 'saveState'
        QtMocHelpers::SlotData<void(bool, qint32, bool)>(122, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 120 }, { QMetaType::Int, 121 }, { QMetaType::Bool, 123 },
        }}),
        // Slot 'saveState'
        QtMocHelpers::SlotData<void(bool, qint32)>(122, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 120 }, { QMetaType::Int, 121 },
        }}),
        // Slot 'undoLoadState'
        QtMocHelpers::SlotData<void()>(124, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setAudioOutputVolume'
        QtMocHelpers::SlotData<void(int, int)>(125, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 126 }, { QMetaType::Int, 127 },
        }}),
        // Slot 'setAudioOutputMuted'
        QtMocHelpers::SlotData<void(bool)>(128, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 129 },
        }}),
        // Slot 'singleStepCPU'
        QtMocHelpers::SlotData<void()>(130, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'dumpRAM'
        QtMocHelpers::SlotData<void(const QString &)>(131, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 18 },
        }}),
        // Slot 'dumpVRAM'
        QtMocHelpers::SlotData<void(const QString &)>(132, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 18 },
        }}),
        // Slot 'dumpSPURAM'
        QtMocHelpers::SlotData<void(const QString &)>(133, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 18 },
        }}),
        // Slot 'saveScreenshot'
        QtMocHelpers::SlotData<void()>(134, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'redrawDisplayWindow'
        QtMocHelpers::SlotData<void()>(135, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'toggleFullscreen'
        QtMocHelpers::SlotData<void()>(136, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setFullscreen'
        QtMocHelpers::SlotData<void(bool)>(137, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 32 },
        }}),
        // Slot 'setSurfaceless'
        QtMocHelpers::SlotData<void(bool)>(138, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 34 },
        }}),
        // Slot 'updateDisplayWindow'
        QtMocHelpers::SlotData<void()>(139, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'requestDisplaySize'
        QtMocHelpers::SlotData<void(float)>(140, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 141 },
        }}),
        // Slot 'applyCheat'
        QtMocHelpers::SlotData<void(const QString &)>(142, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 143 },
        }}),
        // Slot 'reloadPostProcessingShaders'
        QtMocHelpers::SlotData<void()>(144, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updatePostProcessingSettings'
        QtMocHelpers::SlotData<void(bool, bool, bool)>(145, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 146 }, { QMetaType::Bool, 147 }, { QMetaType::Bool, 148 },
        }}),
        // Slot 'clearInputBindStateFromSource'
        QtMocHelpers::SlotData<void(InputBindingKey)>(149, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 150, 151 },
        }}),
        // Slot 'reloadTextureReplacements'
        QtMocHelpers::SlotData<void()>(152, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'captureGPUFrameDump'
        QtMocHelpers::SlotData<void()>(153, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'startControllerTest'
        QtMocHelpers::SlotData<void()>(154, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setGPUThreadRunIdle'
        QtMocHelpers::SlotData<void(bool)>(155, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 60 },
        }}),
        // Slot 'updateFullscreenUITheme'
        QtMocHelpers::SlotData<void()>(156, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'stopInThread'
        QtMocHelpers::SlotData<void()>(157, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'onDisplayWindowMouseButtonEvent'
        QtMocHelpers::SlotData<void(int, bool)>(158, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 159 }, { QMetaType::Bool, 160 },
        }}),
        // Slot 'onDisplayWindowMouseWheelEvent'
        QtMocHelpers::SlotData<void(float, float)>(161, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Float, 162 }, { QMetaType::Float, 163 },
        }}),
        // Slot 'onDisplayWindowResized'
        QtMocHelpers::SlotData<void(int, int, float)>(164, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 38 }, { QMetaType::Int, 39 }, { QMetaType::Float, 141 },
        }}),
        // Slot 'onDisplayWindowKeyEvent'
        QtMocHelpers::SlotData<void(int, bool)>(165, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 151 }, { QMetaType::Bool, 160 },
        }}),
        // Slot 'onDisplayWindowTextEntered'
        QtMocHelpers::SlotData<void(const QString &)>(166, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 167 },
        }}),
        // Slot 'doBackgroundControllerPoll'
        QtMocHelpers::SlotData<void()>(168, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'runOnEmuThread'
        QtMocHelpers::SlotData<void(const std::function<void()> &)>(169, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 170, 171 },
        }}),
        // Slot 'processAuxiliaryRenderWindowInputEvent'
        QtMocHelpers::SlotData<void(void *, quint32, quint32, quint32, quint32)>(172, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::VoidStar, 71 }, { QMetaType::UInt, 173 }, { QMetaType::UInt, 174 }, { QMetaType::UInt, 175 },
            { QMetaType::UInt, 176 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<EmuThread, qt_meta_tag_ZN9EmuThreadE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject EmuThread::staticMetaObject = { {
    QMetaObject::SuperData::link<QThread::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9EmuThreadE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9EmuThreadE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN9EmuThreadE_t>.metaTypes,
    nullptr
} };

void EmuThread::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<EmuThread *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->errorReported((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[2]))); break;
        case 1: { bool _r = _t->messageConfirmed((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = std::move(_r); }  break;
        case 2: _t->statusMessage((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->debuggerMessageReported((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 4: _t->settingsResetToDefault((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[2]))); break;
        case 5: _t->systemStarting(); break;
        case 6: _t->systemStarted(); break;
        case 7: _t->systemStopping(); break;
        case 8: _t->systemDestroyed(); break;
        case 9: _t->systemPaused(); break;
        case 10: _t->systemResumed(); break;
        case 11: _t->systemGameChanged((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[3]))); break;
        case 12: _t->systemUndoStateAvailabilityChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<quint64>>(_a[2]))); break;
        case 13: _t->gameListRefreshed(); break;
        case 14: _t->gameListRowsChanged((*reinterpret_cast< std::add_pointer_t<QList<int>>>(_a[1]))); break;
        case 15: { std::optional<WindowInfo> _r = _t->onAcquireRenderWindowRequested((*reinterpret_cast< std::add_pointer_t<RenderAPI>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[4])),(*reinterpret_cast< std::add_pointer_t<Error*>>(_a[5])));
            if (_a[0]) *reinterpret_cast< std::optional<WindowInfo>*>(_a[0]) = std::move(_r); }  break;
        case 16: _t->onResizeRenderWindowRequested((*reinterpret_cast< std::add_pointer_t<qint32>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<qint32>>(_a[2]))); break;
        case 17: _t->onReleaseRenderWindowRequested(); break;
        case 18: _t->focusDisplayWidgetRequested(); break;
        case 19: _t->inputProfileLoaded(); break;
        case 20: _t->mouseModeRequested((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[2]))); break;
        case 21: _t->fullscreenUIStartedOrStopped((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 22: _t->achievementsLoginRequested((*reinterpret_cast< std::add_pointer_t<Achievements::LoginRequestReason>>(_a[1]))); break;
        case 23: _t->achievementsLoginSuccess((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<quint32>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<quint32>>(_a[3])),(*reinterpret_cast< std::add_pointer_t<quint32>>(_a[4]))); break;
        case 24: _t->achievementsRefreshed((*reinterpret_cast< std::add_pointer_t<quint32>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[2]))); break;
        case 25: _t->achievementsActiveChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 26: _t->achievementsHardcoreModeChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 27: _t->achievementsAllProgressRefreshed(); break;
        case 28: _t->mediaCaptureStarted(); break;
        case 29: _t->mediaCaptureStopped(); break;
        case 30: { bool _r = _t->onCreateAuxiliaryRenderWindow((*reinterpret_cast< std::add_pointer_t<RenderAPI>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<qint32>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<qint32>>(_a[3])),(*reinterpret_cast< std::add_pointer_t<quint32>>(_a[4])),(*reinterpret_cast< std::add_pointer_t<quint32>>(_a[5])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[7])),(*reinterpret_cast< std::add_pointer_t<Host::AuxiliaryRenderWindowUserData>>(_a[8])),(*reinterpret_cast< std::add_pointer_t<Host::AuxiliaryRenderWindowHandle*>>(_a[9])),(*reinterpret_cast< std::add_pointer_t<WindowInfo*>>(_a[10])),(*reinterpret_cast< std::add_pointer_t<Error*>>(_a[11])));
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = std::move(_r); }  break;
        case 31: _t->onDestroyAuxiliaryRenderWindow((*reinterpret_cast< std::add_pointer_t<Host::AuxiliaryRenderWindowHandle>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QPoint*>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<QSize*>>(_a[3]))); break;
        case 32: _t->onCoverDownloaderOpenRequested(); break;
        case 33: _t->setDefaultSettings((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[2]))); break;
        case 34: _t->setDefaultSettings((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 35: _t->setDefaultSettings(); break;
        case 36: _t->applySettings((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 37: _t->applySettings(); break;
        case 38: _t->reloadGameSettings((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 39: _t->reloadGameSettings(); break;
        case 40: _t->reloadInputProfile((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 41: _t->reloadInputProfile(); break;
        case 42: _t->reloadCheats((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[4]))); break;
        case 43: _t->updateEmuFolders(); break;
        case 44: _t->updateControllerSettings(); break;
        case 45: _t->reloadInputSources(); break;
        case 46: _t->reloadInputBindings(); break;
        case 47: _t->reloadInputDevices(); break;
        case 48: _t->closeInputSources(); break;
        case 49: _t->startFullscreenUI(); break;
        case 50: _t->stopFullscreenUI(); break;
        case 51: _t->exitFullscreenUI(); break;
        case 52: _t->refreshAchievementsAllProgress(); break;
        case 53: _t->bootSystem((*reinterpret_cast< std::add_pointer_t<std::shared_ptr<SystemBootParameters>>>(_a[1]))); break;
        case 54: _t->resumeSystemFromMostRecentState(); break;
        case 55: _t->shutdownSystem((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[2]))); break;
        case 56: _t->resetSystem((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 57: _t->setSystemPaused((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[2]))); break;
        case 58: _t->setSystemPaused((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 59: _t->changeDisc((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[3]))); break;
        case 60: _t->changeDiscFromPlaylist((*reinterpret_cast< std::add_pointer_t<quint32>>(_a[1]))); break;
        case 61: _t->loadState((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 62: _t->loadState((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<qint32>>(_a[2]))); break;
        case 63: _t->saveState((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[2]))); break;
        case 64: _t->saveState((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 65: _t->saveState((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<qint32>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[3]))); break;
        case 66: _t->saveState((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<qint32>>(_a[2]))); break;
        case 67: _t->undoLoadState(); break;
        case 68: _t->setAudioOutputVolume((*reinterpret_cast< std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[2]))); break;
        case 69: _t->setAudioOutputMuted((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 70: _t->singleStepCPU(); break;
        case 71: _t->dumpRAM((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 72: _t->dumpVRAM((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 73: _t->dumpSPURAM((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 74: _t->saveScreenshot(); break;
        case 75: _t->redrawDisplayWindow(); break;
        case 76: _t->toggleFullscreen(); break;
        case 77: _t->setFullscreen((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 78: _t->setSurfaceless((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 79: _t->updateDisplayWindow(); break;
        case 80: _t->requestDisplaySize((*reinterpret_cast< std::add_pointer_t<float>>(_a[1]))); break;
        case 81: _t->applyCheat((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 82: _t->reloadPostProcessingShaders(); break;
        case 83: _t->updatePostProcessingSettings((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[3]))); break;
        case 84: _t->clearInputBindStateFromSource((*reinterpret_cast< std::add_pointer_t<InputBindingKey>>(_a[1]))); break;
        case 85: _t->reloadTextureReplacements(); break;
        case 86: _t->captureGPUFrameDump(); break;
        case 87: _t->startControllerTest(); break;
        case 88: _t->setGPUThreadRunIdle((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 89: _t->updateFullscreenUITheme(); break;
        case 90: _t->stopInThread(); break;
        case 91: _t->onDisplayWindowMouseButtonEvent((*reinterpret_cast< std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[2]))); break;
        case 92: _t->onDisplayWindowMouseWheelEvent((*reinterpret_cast< std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<float>>(_a[2]))); break;
        case 93: _t->onDisplayWindowResized((*reinterpret_cast< std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<float>>(_a[3]))); break;
        case 94: _t->onDisplayWindowKeyEvent((*reinterpret_cast< std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[2]))); break;
        case 95: _t->onDisplayWindowTextEntered((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 96: _t->doBackgroundControllerPoll(); break;
        case 97: _t->runOnEmuThread((*reinterpret_cast< std::add_pointer_t<std::function<void()>>>(_a[1]))); break;
        case 98: _t->processAuxiliaryRenderWindowInputEvent((*reinterpret_cast< std::add_pointer_t<void*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<quint32>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<quint32>>(_a[3])),(*reinterpret_cast< std::add_pointer_t<quint32>>(_a[4])),(*reinterpret_cast< std::add_pointer_t<quint32>>(_a[5]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 14:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        case 53:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< std::shared_ptr<SystemBootParameters> >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)(const QString & , const QString & )>(_a, &EmuThread::errorReported, 0))
            return;
        if (QtMocHelpers::indexOfMethod<bool (EmuThread::*)(const QString & , const QString & )>(_a, &EmuThread::messageConfirmed, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)(const QString & )>(_a, &EmuThread::statusMessage, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)(const QString & )>(_a, &EmuThread::debuggerMessageReported, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)(bool , bool )>(_a, &EmuThread::settingsResetToDefault, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)()>(_a, &EmuThread::systemStarting, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)()>(_a, &EmuThread::systemStarted, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)()>(_a, &EmuThread::systemStopping, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)()>(_a, &EmuThread::systemDestroyed, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)()>(_a, &EmuThread::systemPaused, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)()>(_a, &EmuThread::systemResumed, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)(const QString & , const QString & , const QString & )>(_a, &EmuThread::systemGameChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)(bool , quint64 )>(_a, &EmuThread::systemUndoStateAvailabilityChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)()>(_a, &EmuThread::gameListRefreshed, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)(const QList<int> & )>(_a, &EmuThread::gameListRowsChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<std::optional<WindowInfo> (EmuThread::*)(RenderAPI , bool , bool , bool , Error * )>(_a, &EmuThread::onAcquireRenderWindowRequested, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)(qint32 , qint32 )>(_a, &EmuThread::onResizeRenderWindowRequested, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)()>(_a, &EmuThread::onReleaseRenderWindowRequested, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)()>(_a, &EmuThread::focusDisplayWidgetRequested, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)()>(_a, &EmuThread::inputProfileLoaded, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)(bool , bool )>(_a, &EmuThread::mouseModeRequested, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)(bool )>(_a, &EmuThread::fullscreenUIStartedOrStopped, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)(Achievements::LoginRequestReason )>(_a, &EmuThread::achievementsLoginRequested, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)(const QString & , quint32 , quint32 , quint32 )>(_a, &EmuThread::achievementsLoginSuccess, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)(quint32 , const QString & )>(_a, &EmuThread::achievementsRefreshed, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)(bool )>(_a, &EmuThread::achievementsActiveChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)(bool )>(_a, &EmuThread::achievementsHardcoreModeChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)()>(_a, &EmuThread::achievementsAllProgressRefreshed, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)()>(_a, &EmuThread::mediaCaptureStarted, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)()>(_a, &EmuThread::mediaCaptureStopped, 29))
            return;
        if (QtMocHelpers::indexOfMethod<bool (EmuThread::*)(RenderAPI , qint32 , qint32 , quint32 , quint32 , const QString & , const QString & , Host::AuxiliaryRenderWindowUserData , Host::AuxiliaryRenderWindowHandle * , WindowInfo * , Error * )>(_a, &EmuThread::onCreateAuxiliaryRenderWindow, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)(Host::AuxiliaryRenderWindowHandle , QPoint * , QSize * )>(_a, &EmuThread::onDestroyAuxiliaryRenderWindow, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (EmuThread::*)()>(_a, &EmuThread::onCoverDownloaderOpenRequested, 32))
            return;
    }
}

const QMetaObject *EmuThread::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *EmuThread::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9EmuThreadE_t>.strings))
        return static_cast<void*>(this);
    return QThread::qt_metacast(_clname);
}

int EmuThread::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QThread::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 99)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 99;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 99)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 99;
    }
    return _id;
}

// SIGNAL 0
void EmuThread::errorReported(const QString & _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}

// SIGNAL 1
bool EmuThread::messageConfirmed(const QString & _t1, const QString & _t2)
{
    bool _t0{};
    QMetaObject::activate<bool>(this, &staticMetaObject, 1, std::addressof(_t0), _t1, _t2);
    return _t0;
}

// SIGNAL 2
void EmuThread::statusMessage(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void EmuThread::debuggerMessageReported(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void EmuThread::settingsResetToDefault(bool _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1, _t2);
}

// SIGNAL 5
void EmuThread::systemStarting()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

// SIGNAL 6
void EmuThread::systemStarted()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void EmuThread::systemStopping()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void EmuThread::systemDestroyed()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void EmuThread::systemPaused()
{
    QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
}

// SIGNAL 10
void EmuThread::systemResumed()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}

// SIGNAL 11
void EmuThread::systemGameChanged(const QString & _t1, const QString & _t2, const QString & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1, _t2, _t3);
}

// SIGNAL 12
void EmuThread::systemUndoStateAvailabilityChanged(bool _t1, quint64 _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1, _t2);
}

// SIGNAL 13
void EmuThread::gameListRefreshed()
{
    QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}

// SIGNAL 14
void EmuThread::gameListRowsChanged(const QList<int> & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
std::optional<WindowInfo> EmuThread::onAcquireRenderWindowRequested(RenderAPI _t1, bool _t2, bool _t3, bool _t4, Error * _t5)
{
    std::optional<WindowInfo> _t0{};
    QMetaObject::activate<std::optional<WindowInfo>>(this, &staticMetaObject, 15, std::addressof(_t0), _t1, _t2, _t3, _t4, _t5);
    return _t0;
}

// SIGNAL 16
void EmuThread::onResizeRenderWindowRequested(qint32 _t1, qint32 _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1, _t2);
}

// SIGNAL 17
void EmuThread::onReleaseRenderWindowRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
}

// SIGNAL 18
void EmuThread::focusDisplayWidgetRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 18, nullptr);
}

// SIGNAL 19
void EmuThread::inputProfileLoaded()
{
    QMetaObject::activate(this, &staticMetaObject, 19, nullptr);
}

// SIGNAL 20
void EmuThread::mouseModeRequested(bool _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1, _t2);
}

// SIGNAL 21
void EmuThread::fullscreenUIStartedOrStopped(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void EmuThread::achievementsLoginRequested(Achievements::LoginRequestReason _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void EmuThread::achievementsLoginSuccess(const QString & _t1, quint32 _t2, quint32 _t3, quint32 _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 24
void EmuThread::achievementsRefreshed(quint32 _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1, _t2);
}

// SIGNAL 25
void EmuThread::achievementsActiveChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1);
}

// SIGNAL 26
void EmuThread::achievementsHardcoreModeChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 26, nullptr, _t1);
}

// SIGNAL 27
void EmuThread::achievementsAllProgressRefreshed()
{
    QMetaObject::activate(this, &staticMetaObject, 27, nullptr);
}

// SIGNAL 28
void EmuThread::mediaCaptureStarted()
{
    QMetaObject::activate(this, &staticMetaObject, 28, nullptr);
}

// SIGNAL 29
void EmuThread::mediaCaptureStopped()
{
    QMetaObject::activate(this, &staticMetaObject, 29, nullptr);
}

// SIGNAL 30
bool EmuThread::onCreateAuxiliaryRenderWindow(RenderAPI _t1, qint32 _t2, qint32 _t3, quint32 _t4, quint32 _t5, const QString & _t6, const QString & _t7, Host::AuxiliaryRenderWindowUserData _t8, Host::AuxiliaryRenderWindowHandle * _t9, WindowInfo * _t10, Error * _t11)
{
    bool _t0{};
    QMetaObject::activate<bool>(this, &staticMetaObject, 30, std::addressof(_t0), _t1, _t2, _t3, _t4, _t5, _t6, _t7, _t8, _t9, _t10, _t11);
    return _t0;
}

// SIGNAL 31
void EmuThread::onDestroyAuxiliaryRenderWindow(Host::AuxiliaryRenderWindowHandle _t1, QPoint * _t2, QSize * _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1, _t2, _t3);
}

// SIGNAL 32
void EmuThread::onCoverDownloaderOpenRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 32, nullptr);
}
namespace {
struct qt_meta_tag_ZN20InputDeviceListModelE_t {};
} // unnamed namespace

template <> constexpr inline auto InputDeviceListModel::qt_create_metaobjectdata<qt_meta_tag_ZN20InputDeviceListModelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "InputDeviceListModel",
        "onDeviceConnected",
        "",
        "InputBindingKey",
        "key",
        "identifier",
        "device_name",
        "vibration_motors",
        "onDeviceDisconnected",
        "resetLists",
        "DeviceList",
        "devices",
        "motors"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'onDeviceConnected'
        QtMocHelpers::SlotData<void(const InputBindingKey &, const QString &, const QString &, const QStringList &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { QMetaType::QString, 5 }, { QMetaType::QString, 6 }, { QMetaType::QStringList, 7 },
        }}),
        // Slot 'onDeviceDisconnected'
        QtMocHelpers::SlotData<void(const InputBindingKey &, const QString &)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { QMetaType::QString, 5 },
        }}),
        // Slot 'resetLists'
        QtMocHelpers::SlotData<void(const DeviceList &, const QStringList &)>(9, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 10, 11 }, { QMetaType::QStringList, 12 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<InputDeviceListModel, qt_meta_tag_ZN20InputDeviceListModelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject InputDeviceListModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QAbstractListModel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20InputDeviceListModelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20InputDeviceListModelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20InputDeviceListModelE_t>.metaTypes,
    nullptr
} };

void InputDeviceListModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<InputDeviceListModel *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->onDeviceConnected((*reinterpret_cast< std::add_pointer_t<InputBindingKey>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast< std::add_pointer_t<QStringList>>(_a[4]))); break;
        case 1: _t->onDeviceDisconnected((*reinterpret_cast< std::add_pointer_t<InputBindingKey>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[2]))); break;
        case 2: _t->resetLists((*reinterpret_cast< std::add_pointer_t<DeviceList>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QStringList>>(_a[2]))); break;
        default: ;
        }
    }
}

const QMetaObject *InputDeviceListModel::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *InputDeviceListModel::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20InputDeviceListModelE_t>.strings))
        return static_cast<void*>(this);
    return QAbstractListModel::qt_metacast(_clname);
}

int InputDeviceListModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAbstractListModel::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 3;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN11QtAsyncTaskE_t {};
} // unnamed namespace

template <> constexpr inline auto QtAsyncTask::qt_create_metaobjectdata<qt_meta_tag_ZN11QtAsyncTaskE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QtAsyncTask",
        "completed",
        "",
        "QtAsyncTask*",
        "self"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'completed'
        QtMocHelpers::SignalData<void(QtAsyncTask *)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QtAsyncTask, qt_meta_tag_ZN11QtAsyncTaskE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QtAsyncTask::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QtAsyncTaskE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QtAsyncTaskE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11QtAsyncTaskE_t>.metaTypes,
    nullptr
} };

void QtAsyncTask::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QtAsyncTask *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->completed((*reinterpret_cast< std::add_pointer_t<QtAsyncTask*>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QtAsyncTask* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (QtAsyncTask::*)(QtAsyncTask * )>(_a, &QtAsyncTask::completed, 0))
            return;
    }
}

const QMetaObject *QtAsyncTask::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *QtAsyncTask::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QtAsyncTaskE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int QtAsyncTask::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void QtAsyncTask::completed(QtAsyncTask * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
QT_WARNING_POP
