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

#include "../../../../../qtquickeffectmaker/tools/qqem/effectmanager.h"
#include <QtNetwork/QSslError>
#include <QtGui/qtextcursor.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 'effectmanager.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.12.0. 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_ZN11EffectErrorE_t {};
} // unnamed namespace

template <> constexpr inline auto EffectError::qt_create_metaobjectdata<qt_meta_tag_ZN11EffectErrorE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "EffectError",
        "message",
        "line",
        "type"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'message'
        QtMocHelpers::PropertyData<QString>(1, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'line'
        QtMocHelpers::PropertyData<int>(2, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'type'
        QtMocHelpers::PropertyData<int>(3, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<EffectError, qt_meta_tag_ZN11EffectErrorE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject EffectError::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11EffectErrorE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11EffectErrorE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11EffectErrorE_t>.metaTypes,
    nullptr
} };

void EffectError::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<EffectError *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QString*>(_v) = _t->m_message; break;
        case 1: *reinterpret_cast<int*>(_v) = _t->m_line; break;
        case 2: *reinterpret_cast<int*>(_v) = _t->m_type; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->m_message, *reinterpret_cast<QString*>(_v)); break;
        case 1: QtMocHelpers::setProperty(_t->m_line, *reinterpret_cast<int*>(_v)); break;
        case 2: QtMocHelpers::setProperty(_t->m_type, *reinterpret_cast<int*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN13EffectManagerE_t {};
} // unnamed namespace

template <> constexpr inline auto EffectManager::qt_create_metaobjectdata<qt_meta_tag_ZN13EffectManagerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "EffectManager",
        "QML.Element",
        "auto",
        "uniformModelChanged",
        "",
        "fragmentShaderChanged",
        "vertexShaderChanged",
        "unsavedChangesChanged",
        "hasProjectFilenameChanged",
        "projectFilenameChanged",
        "projectNameChanged",
        "projectDirectoryChanged",
        "exportFilenameChanged",
        "exportDirectoryChanged",
        "exportFlagsChanged",
        "shadersBaked",
        "nodeViewChanged",
        "effectErrorChanged",
        "fragmentShaderFilenameChanged",
        "vertexShaderFilenameChanged",
        "qmlComponentStringChanged",
        "shadersUpToDateChanged",
        "autoPlayEffectChanged",
        "addNodeModelChanged",
        "effectPaddingChanged",
        "effectHeadingsChanged",
        "settingsChanged",
        "generateVertexShader",
        "includeUniforms",
        "generateFragmentShader",
        "updateQmlComponent",
        "initialize",
        "loadEffectNode",
        "NodesModel::Node",
        "filename",
        "addEffectNode",
        "startNodeId",
        "endNodeId",
        "deleteEffectNodes",
        "QList<int>",
        "nodeIds",
        "loadProject",
        "QUrl",
        "saveProject",
        "newProject",
        "filepath",
        "clearNodeView",
        "createProjectDir",
        "closeProject",
        "exportEffect",
        "dirPath",
        "exportFlags",
        "qsbVersionIndex",
        "cleanupProject",
        "cleanupNodeView",
        "saveSelectedNode",
        "updateBakedShaderVersions",
        "bakeShaders",
        "forced",
        "getHelpTextString",
        "updateAddNodeData",
        "showHideAddNodeGroup",
        "groupName",
        "show",
        "refreshAddNodesList",
        "setEffectPadding",
        "QRect",
        "newEffectPadding",
        "setEffectHeadings",
        "newEffectHeadings",
        "stripFileFromURL",
        "urlString",
        "addFileToURL",
        "getDirectory",
        "path",
        "useFileScheme",
        "getDefaultImagesDirectory",
        "autoIndentCurrentCode",
        "codeTab",
        "code",
        "processKey",
        "keyCode",
        "modifiers",
        "QQuickTextEdit*",
        "textEdit",
        "setEffectError",
        "errorMessage",
        "type",
        "lineNumber",
        "resetEffectError",
        "mipmapPropertyName",
        "name",
        "getSupportedImageFormatsFilter",
        "effectUpdateDelay",
        "uniformModel",
        "UniformModel*",
        "nodeView",
        "NodeView*",
        "codeHelper",
        "CodeHelper*",
        "fragmentShader",
        "vertexShader",
        "fragmentShaderFilename",
        "vertexShaderFilename",
        "qmlComponentString",
        "effectError",
        "EffectError",
        "unsavedChanges",
        "hasProjectFilename",
        "projectName",
        "projectFilename",
        "projectDirectory",
        "exportFilename",
        "exportDirectory",
        "shadersUpToDate",
        "autoPlayEffect",
        "addNodeModel",
        "AddNodeModel*",
        "effectPadding",
        "effectHeadings",
        "settings",
        "ApplicationSettings*"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'uniformModelChanged'
        QtMocHelpers::SignalData<void()>(3, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fragmentShaderChanged'
        QtMocHelpers::SignalData<void()>(5, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'vertexShaderChanged'
        QtMocHelpers::SignalData<void()>(6, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'unsavedChangesChanged'
        QtMocHelpers::SignalData<void()>(7, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'hasProjectFilenameChanged'
        QtMocHelpers::SignalData<void()>(8, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'projectFilenameChanged'
        QtMocHelpers::SignalData<void()>(9, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'projectNameChanged'
        QtMocHelpers::SignalData<void()>(10, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'projectDirectoryChanged'
        QtMocHelpers::SignalData<void()>(11, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'exportFilenameChanged'
        QtMocHelpers::SignalData<void()>(12, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'exportDirectoryChanged'
        QtMocHelpers::SignalData<void()>(13, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'exportFlagsChanged'
        QtMocHelpers::SignalData<void()>(14, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'shadersBaked'
        QtMocHelpers::SignalData<void()>(15, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'nodeViewChanged'
        QtMocHelpers::SignalData<void()>(16, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'effectErrorChanged'
        QtMocHelpers::SignalData<void()>(17, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fragmentShaderFilenameChanged'
        QtMocHelpers::SignalData<void()>(18, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'vertexShaderFilenameChanged'
        QtMocHelpers::SignalData<void()>(19, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'qmlComponentStringChanged'
        QtMocHelpers::SignalData<void()>(20, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'shadersUpToDateChanged'
        QtMocHelpers::SignalData<void()>(21, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'autoPlayEffectChanged'
        QtMocHelpers::SignalData<void()>(22, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'addNodeModelChanged'
        QtMocHelpers::SignalData<void()>(23, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'effectPaddingChanged'
        QtMocHelpers::SignalData<void()>(24, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'effectHeadingsChanged'
        QtMocHelpers::SignalData<void()>(25, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'settingsChanged'
        QtMocHelpers::SignalData<void()>(26, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'generateVertexShader'
        QtMocHelpers::SlotData<QString(bool)>(27, 4, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::Bool, 28 },
        }}),
        // Slot 'generateVertexShader'
        QtMocHelpers::SlotData<QString()>(27, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString),
        // Slot 'generateFragmentShader'
        QtMocHelpers::SlotData<QString(bool)>(29, 4, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::Bool, 28 },
        }}),
        // Slot 'generateFragmentShader'
        QtMocHelpers::SlotData<QString()>(29, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString),
        // Slot 'updateQmlComponent'
        QtMocHelpers::SlotData<void()>(30, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'initialize'
        QtMocHelpers::SlotData<void()>(31, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'loadEffectNode'
        QtMocHelpers::SlotData<NodesModel::Node(const QString &)>(32, 4, QMC::AccessPublic, 0x80000000 | 33, {{
            { QMetaType::QString, 34 },
        }}),
        // Slot 'addEffectNode'
        QtMocHelpers::SlotData<bool(const QString &, int, int)>(35, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 34 }, { QMetaType::Int, 36 }, { QMetaType::Int, 37 },
        }}),
        // Slot 'addEffectNode'
        QtMocHelpers::SlotData<bool(const QString &, int)>(35, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QString, 34 }, { QMetaType::Int, 36 },
        }}),
        // Slot 'addEffectNode'
        QtMocHelpers::SlotData<bool(const QString &)>(35, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QString, 34 },
        }}),
        // Slot 'deleteEffectNodes'
        QtMocHelpers::SlotData<bool(QList<int>)>(38, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 39, 40 },
        }}),
        // Slot 'loadProject'
        QtMocHelpers::SlotData<bool(const QUrl &)>(41, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 42, 34 },
        }}),
        // Slot 'saveProject'
        QtMocHelpers::SlotData<bool(const QUrl &)>(43, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 42, 34 },
        }}),
        // Slot 'saveProject'
        QtMocHelpers::SlotData<bool()>(43, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool),
        // Slot 'newProject'
        QtMocHelpers::SlotData<bool(const QString &, const QString &, bool, bool)>(44, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 45 }, { QMetaType::QString, 34 }, { QMetaType::Bool, 46 }, { QMetaType::Bool, 47 },
        }}),
        // Slot 'newProject'
        QtMocHelpers::SlotData<bool(const QString &, const QString &, bool)>(44, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QString, 45 }, { QMetaType::QString, 34 }, { QMetaType::Bool, 46 },
        }}),
        // Slot 'closeProject'
        QtMocHelpers::SlotData<void()>(48, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'exportEffect'
        QtMocHelpers::SlotData<bool(const QString &, const QString &, int, int)>(49, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 50 }, { QMetaType::QString, 34 }, { QMetaType::Int, 51 }, { QMetaType::Int, 52 },
        }}),
        // Slot 'cleanupProject'
        QtMocHelpers::SlotData<void()>(53, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'cleanupNodeView'
        QtMocHelpers::SlotData<void(bool)>(54, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 31 },
        }}),
        // Slot 'cleanupNodeView'
        QtMocHelpers::SlotData<void()>(54, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'saveSelectedNode'
        QtMocHelpers::SlotData<bool(const QUrl &)>(55, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 42, 34 },
        }}),
        // Slot 'updateBakedShaderVersions'
        QtMocHelpers::SlotData<void()>(56, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'bakeShaders'
        QtMocHelpers::SlotData<void(bool)>(57, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 58 },
        }}),
        // Slot 'bakeShaders'
        QtMocHelpers::SlotData<void()>(57, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'getHelpTextString'
        QtMocHelpers::SlotData<QString()>(59, 4, QMC::AccessPublic, QMetaType::QString),
        // Slot 'updateAddNodeData'
        QtMocHelpers::SlotData<void()>(60, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'showHideAddNodeGroup'
        QtMocHelpers::SlotData<void(const QString &, bool)>(61, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 62 }, { QMetaType::Bool, 63 },
        }}),
        // Slot 'refreshAddNodesList'
        QtMocHelpers::SlotData<void()>(64, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setEffectPadding'
        QtMocHelpers::SlotData<void(const QRect &)>(65, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 66, 67 },
        }}),
        // Slot 'setEffectHeadings'
        QtMocHelpers::SlotData<void(const QString &)>(68, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 69 },
        }}),
        // Slot 'stripFileFromURL'
        QtMocHelpers::SlotData<QString(const QString &) const>(70, 4, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 71 },
        }}),
        // Slot 'addFileToURL'
        QtMocHelpers::SlotData<QString(const QString &) const>(72, 4, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 71 },
        }}),
        // Slot 'getDirectory'
        QtMocHelpers::SlotData<QString(const QString &, bool) const>(73, 4, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 74 }, { QMetaType::Bool, 75 },
        }}),
        // Slot 'getDirectory'
        QtMocHelpers::SlotData<QString(const QString &) const>(73, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString, {{
            { QMetaType::QString, 74 },
        }}),
        // Slot 'getDefaultImagesDirectory'
        QtMocHelpers::SlotData<QString(bool) const>(76, 4, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::Bool, 75 },
        }}),
        // Slot 'getDefaultImagesDirectory'
        QtMocHelpers::SlotData<QString() const>(76, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString),
        // Slot 'autoIndentCurrentCode'
        QtMocHelpers::SlotData<void(int, const QString &)>(77, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 78 }, { QMetaType::QString, 79 },
        }}),
        // Slot 'processKey'
        QtMocHelpers::SlotData<bool(int, int, int, QQuickTextEdit *)>(80, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Int, 78 }, { QMetaType::Int, 81 }, { QMetaType::Int, 82 }, { 0x80000000 | 83, 84 },
        }}),
        // Slot 'setEffectError'
        QtMocHelpers::SlotData<void(const QString &, int, int)>(85, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 86 }, { QMetaType::Int, 87 }, { QMetaType::Int, 88 },
        }}),
        // Slot 'setEffectError'
        QtMocHelpers::SlotData<void(const QString &, int)>(85, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 86 }, { QMetaType::Int, 87 },
        }}),
        // Slot 'setEffectError'
        QtMocHelpers::SlotData<void(const QString &)>(85, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 86 },
        }}),
        // Slot 'resetEffectError'
        QtMocHelpers::SlotData<void(int)>(89, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 87 },
        }}),
        // Slot 'resetEffectError'
        QtMocHelpers::SlotData<void()>(89, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'mipmapPropertyName'
        QtMocHelpers::MethodData<QString(const QString &) const>(90, 4, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 91 },
        }}),
        // Method 'getSupportedImageFormatsFilter'
        QtMocHelpers::MethodData<QString() const>(92, 4, QMC::AccessPublic, QMetaType::QString),
        // Method 'effectUpdateDelay'
        QtMocHelpers::MethodData<int() const>(93, 4, QMC::AccessPublic, QMetaType::Int),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'uniformModel'
        QtMocHelpers::PropertyData<UniformModel*>(94, 0x80000000 | 95, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 0),
        // property 'nodeView'
        QtMocHelpers::PropertyData<NodeView*>(96, 0x80000000 | 97, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 12),
        // property 'codeHelper'
        QtMocHelpers::PropertyData<CodeHelper*>(98, 0x80000000 | 99, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'fragmentShader'
        QtMocHelpers::PropertyData<QString>(100, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'vertexShader'
        QtMocHelpers::PropertyData<QString>(101, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'fragmentShaderFilename'
        QtMocHelpers::PropertyData<QString>(102, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 14),
        // property 'vertexShaderFilename'
        QtMocHelpers::PropertyData<QString>(103, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 15),
        // property 'qmlComponentString'
        QtMocHelpers::PropertyData<QString>(104, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'effectError'
        QtMocHelpers::PropertyData<EffectError>(105, 0x80000000 | 106, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 13),
        // property 'unsavedChanges'
        QtMocHelpers::PropertyData<bool>(107, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 3),
        // property 'hasProjectFilename'
        QtMocHelpers::PropertyData<bool>(108, QMetaType::Bool, QMC::DefaultPropertyFlags, 4),
        // property 'projectName'
        QtMocHelpers::PropertyData<QString>(109, QMetaType::QString, QMC::DefaultPropertyFlags, 6),
        // property 'projectFilename'
        QtMocHelpers::PropertyData<QString>(110, QMetaType::QString, QMC::DefaultPropertyFlags, 5),
        // property 'projectDirectory'
        QtMocHelpers::PropertyData<QString>(111, QMetaType::QString, QMC::DefaultPropertyFlags, 7),
        // property 'exportFilename'
        QtMocHelpers::PropertyData<QString>(112, QMetaType::QString, QMC::DefaultPropertyFlags, 8),
        // property 'exportDirectory'
        QtMocHelpers::PropertyData<QString>(113, QMetaType::QString, QMC::DefaultPropertyFlags, 9),
        // property 'exportFlags'
        QtMocHelpers::PropertyData<int>(51, QMetaType::Int, QMC::DefaultPropertyFlags, 10),
        // property 'shadersUpToDate'
        QtMocHelpers::PropertyData<bool>(114, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 17),
        // property 'autoPlayEffect'
        QtMocHelpers::PropertyData<bool>(115, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 18),
        // property 'addNodeModel'
        QtMocHelpers::PropertyData<AddNodeModel*>(116, 0x80000000 | 117, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 19),
        // property 'effectPadding'
        QtMocHelpers::PropertyData<QRect>(118, 0x80000000 | 66, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 20),
        // property 'effectHeadings'
        QtMocHelpers::PropertyData<QString>(119, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 21),
        // property 'settings'
        QtMocHelpers::PropertyData<ApplicationSettings*>(120, 0x80000000 | 121, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 22),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<EffectManager, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject EffectManager::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13EffectManagerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13EffectManagerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13EffectManagerE_t>.metaTypes,
    nullptr
} };

void EffectManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<EffectManager *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->uniformModelChanged(); break;
        case 1: _t->fragmentShaderChanged(); break;
        case 2: _t->vertexShaderChanged(); break;
        case 3: _t->unsavedChangesChanged(); break;
        case 4: _t->hasProjectFilenameChanged(); break;
        case 5: _t->projectFilenameChanged(); break;
        case 6: _t->projectNameChanged(); break;
        case 7: _t->projectDirectoryChanged(); break;
        case 8: _t->exportFilenameChanged(); break;
        case 9: _t->exportDirectoryChanged(); break;
        case 10: _t->exportFlagsChanged(); break;
        case 11: _t->shadersBaked(); break;
        case 12: _t->nodeViewChanged(); break;
        case 13: _t->effectErrorChanged(); break;
        case 14: _t->fragmentShaderFilenameChanged(); break;
        case 15: _t->vertexShaderFilenameChanged(); break;
        case 16: _t->qmlComponentStringChanged(); break;
        case 17: _t->shadersUpToDateChanged(); break;
        case 18: _t->autoPlayEffectChanged(); break;
        case 19: _t->addNodeModelChanged(); break;
        case 20: _t->effectPaddingChanged(); break;
        case 21: _t->effectHeadingsChanged(); break;
        case 22: _t->settingsChanged(); break;
        case 23: { QString _r = _t->generateVertexShader((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 24: { QString _r = _t->generateVertexShader();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 25: { QString _r = _t->generateFragmentShader((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 26: { QString _r = _t->generateFragmentShader();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 27: _t->updateQmlComponent(); break;
        case 28: _t->initialize(); break;
        case 29: { NodesModel::Node _r = _t->loadEffectNode((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NodesModel::Node*>(_a[0]) = std::move(_r); }  break;
        case 30: { bool _r = _t->addEffectNode((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 31: { bool _r = _t->addEffectNode((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 32: { bool _r = _t->addEffectNode((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 33: { bool _r = _t->deleteEffectNodes((*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 34: { bool _r = _t->loadProject((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 35: { bool _r = _t->saveProject((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 36: { bool _r = _t->saveProject();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 37: { bool _r = _t->newProject((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 38: { bool _r = _t->newProject((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 39: _t->closeProject(); break;
        case 40: { bool _r = _t->exportEffect((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 41: _t->cleanupProject(); break;
        case 42: _t->cleanupNodeView((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 43: _t->cleanupNodeView(); break;
        case 44: { bool _r = _t->saveSelectedNode((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 45: _t->updateBakedShaderVersions(); break;
        case 46: _t->bakeShaders((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 47: _t->bakeShaders(); break;
        case 48: { QString _r = _t->getHelpTextString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 49: _t->updateAddNodeData(); break;
        case 50: _t->showHideAddNodeGroup((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 51: _t->refreshAddNodesList(); break;
        case 52: _t->setEffectPadding((*reinterpret_cast<std::add_pointer_t<QRect>>(_a[1]))); break;
        case 53: _t->setEffectHeadings((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 54: { QString _r = _t->stripFileFromURL((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 55: { QString _r = _t->addFileToURL((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 56: { QString _r = _t->getDirectory((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 57: { QString _r = _t->getDirectory((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 58: { QString _r = _t->getDefaultImagesDirectory((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 59: { QString _r = _t->getDefaultImagesDirectory();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 60: _t->autoIndentCurrentCode((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 61: { bool _r = _t->processKey((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QQuickTextEdit*>>(_a[4])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 62: _t->setEffectError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 63: _t->setEffectError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 64: _t->setEffectError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 65: _t->resetEffectError((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 66: _t->resetEffectError(); break;
        case 67: { QString _r = _t->mipmapPropertyName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 68: { QString _r = _t->getSupportedImageFormatsFilter();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 69: { int _r = _t->effectUpdateDelay();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 33:
            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 61:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 3:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QQuickTextEdit* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::uniformModelChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::fragmentShaderChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::vertexShaderChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::unsavedChangesChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::hasProjectFilenameChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::projectFilenameChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::projectNameChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::projectDirectoryChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::exportFilenameChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::exportDirectoryChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::exportFlagsChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::shadersBaked, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::nodeViewChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::effectErrorChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::fragmentShaderFilenameChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::vertexShaderFilenameChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::qmlComponentStringChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::shadersUpToDateChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::autoPlayEffectChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::addNodeModelChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::effectPaddingChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::effectHeadingsChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (EffectManager::*)()>(_a, &EffectManager::settingsChanged, 22))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 19:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< AddNodeModel* >(); break;
        case 22:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< ApplicationSettings* >(); break;
        case 2:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< CodeHelper* >(); break;
        case 1:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< NodeView* >(); break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< UniformModel* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<UniformModel**>(_v) = _t->uniformModel(); break;
        case 1: *reinterpret_cast<NodeView**>(_v) = _t->nodeView(); break;
        case 2: *reinterpret_cast<CodeHelper**>(_v) = _t->codeHelper(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->fragmentShader(); break;
        case 4: *reinterpret_cast<QString*>(_v) = _t->vertexShader(); break;
        case 5: *reinterpret_cast<QString*>(_v) = _t->fragmentShaderFilename(); break;
        case 6: *reinterpret_cast<QString*>(_v) = _t->vertexShaderFilename(); break;
        case 7: *reinterpret_cast<QString*>(_v) = _t->qmlComponentString(); break;
        case 8: *reinterpret_cast<EffectError*>(_v) = _t->effectError(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->unsavedChanges(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->hasProjectFilename(); break;
        case 11: *reinterpret_cast<QString*>(_v) = _t->projectName(); break;
        case 12: *reinterpret_cast<QString*>(_v) = _t->projectFilename(); break;
        case 13: *reinterpret_cast<QString*>(_v) = _t->projectDirectory(); break;
        case 14: *reinterpret_cast<QString*>(_v) = _t->exportFilename(); break;
        case 15: *reinterpret_cast<QString*>(_v) = _t->exportDirectory(); break;
        case 16: *reinterpret_cast<int*>(_v) = _t->exportFlags(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->shadersUpToDate(); break;
        case 18: *reinterpret_cast<bool*>(_v) = _t->autoPlayEffect(); break;
        case 19: *reinterpret_cast<AddNodeModel**>(_v) = _t->addNodeModel(); break;
        case 20: *reinterpret_cast<QRect*>(_v) = _t->effectPadding(); break;
        case 21: *reinterpret_cast<QString*>(_v) = _t->effectHeadings(); break;
        case 22: *reinterpret_cast<ApplicationSettings**>(_v) = _t->settings(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setUniformModel(*reinterpret_cast<UniformModel**>(_v)); break;
        case 1: _t->setNodeView(*reinterpret_cast<NodeView**>(_v)); break;
        case 3: _t->setFragmentShader(*reinterpret_cast<QString*>(_v)); break;
        case 4: _t->setVertexShader(*reinterpret_cast<QString*>(_v)); break;
        case 5: _t->setFragmentShaderFilename(*reinterpret_cast<QString*>(_v)); break;
        case 6: _t->setVertexShaderFilename(*reinterpret_cast<QString*>(_v)); break;
        case 7: _t->setQmlComponentString(*reinterpret_cast<QString*>(_v)); break;
        case 9: _t->setUnsavedChanges(*reinterpret_cast<bool*>(_v)); break;
        case 17: _t->setShadersUpToDate(*reinterpret_cast<bool*>(_v)); break;
        case 18: _t->setAutoPlayEffect(*reinterpret_cast<bool*>(_v)); break;
        case 20: _t->setEffectPadding(*reinterpret_cast<QRect*>(_v)); break;
        case 21: _t->setEffectHeadings(*reinterpret_cast<QString*>(_v)); break;
        default: break;
        }
    }
}

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

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

int EffectManager::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 < 70)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 70;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 70)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 70;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 23;
    }
    return _id;
}

// SIGNAL 0
void EffectManager::uniformModelChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void EffectManager::fragmentShaderChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void EffectManager::vertexShaderChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void EffectManager::unsavedChangesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void EffectManager::hasProjectFilenameChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

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

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

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

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

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

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

// SIGNAL 11
void EffectManager::shadersBaked()
{
    QMetaObject::activate(this, &staticMetaObject, 11, nullptr);
}

// SIGNAL 12
void EffectManager::nodeViewChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
}

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

// SIGNAL 14
void EffectManager::fragmentShaderFilenameChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 14, nullptr);
}

// SIGNAL 15
void EffectManager::vertexShaderFilenameChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
}

// SIGNAL 16
void EffectManager::qmlComponentStringChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

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

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

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

// SIGNAL 20
void EffectManager::effectPaddingChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 20, nullptr);
}

// SIGNAL 21
void EffectManager::effectHeadingsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 21, nullptr);
}

// SIGNAL 22
void EffectManager::settingsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 22, nullptr);
}
QT_WARNING_POP
