/****************************************************************************
** Meta object code from reading C++ file 'qt3dquickvaluetypes_p.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 "../../../../../../qt3d/src/quick3d/quick3d/qt3dquickvaluetypes_p.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'qt3dquickvaluetypes_p.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_ZN8Qt3DCore5Quick22QQuick3DColorValueTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto Qt3DCore::Quick::QQuick3DColorValueType::qt_create_metaobjectdata<qt_meta_tag_ZN8Qt3DCore5Quick22QQuick3DColorValueTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Qt3DCore::Quick::QQuick3DColorValueType",
        "QML.AddedInVersion",
        "512",
        "QML.Foreign",
        "QColor",
        "QML.Element",
        "color",
        "QML.Extended",
        "QQuick3DColorValueType",
        "toString",
        "",
        "alpha",
        "QVariant",
        "value",
        "lighter",
        "factor",
        "darker",
        "tint",
        "r",
        "g",
        "b",
        "a",
        "hsvHue",
        "hsvSaturation",
        "hsvValue",
        "hslHue",
        "hslSaturation",
        "hslLightness",
        "valid"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(9, 10, QMC::AccessPublic, QMetaType::QString),
        // Method 'alpha'
        QtMocHelpers::MethodData<QVariant(qreal) const>(11, 10, QMC::AccessPublic, 0x80000000 | 12, {{
            { QMetaType::QReal, 13 },
        }}),
        // Method 'lighter'
        QtMocHelpers::MethodData<QVariant(qreal) const>(14, 10, QMC::AccessPublic, 0x80000000 | 12, {{
            { QMetaType::QReal, 15 },
        }}),
        // Method 'lighter'
        QtMocHelpers::MethodData<QVariant() const>(14, 10, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 12),
        // Method 'darker'
        QtMocHelpers::MethodData<QVariant(qreal) const>(16, 10, QMC::AccessPublic, 0x80000000 | 12, {{
            { QMetaType::QReal, 15 },
        }}),
        // Method 'darker'
        QtMocHelpers::MethodData<QVariant() const>(16, 10, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 12),
        // Method 'tint'
        QtMocHelpers::MethodData<QVariant(QVariant) const>(17, 10, QMC::AccessPublic, 0x80000000 | 12, {{
            { 0x80000000 | 12, 15 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'r'
        QtMocHelpers::PropertyData<qreal>(18, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'g'
        QtMocHelpers::PropertyData<qreal>(19, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'b'
        QtMocHelpers::PropertyData<qreal>(20, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'a'
        QtMocHelpers::PropertyData<qreal>(21, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'hsvHue'
        QtMocHelpers::PropertyData<qreal>(22, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'hsvSaturation'
        QtMocHelpers::PropertyData<qreal>(23, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'hsvValue'
        QtMocHelpers::PropertyData<qreal>(24, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'hslHue'
        QtMocHelpers::PropertyData<qreal>(25, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'hslSaturation'
        QtMocHelpers::PropertyData<qreal>(26, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'hslLightness'
        QtMocHelpers::PropertyData<qreal>(27, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'valid'
        QtMocHelpers::PropertyData<bool>(28, QMetaType::Bool, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QQuick3DColorValueType, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Qt3DCore::Quick::QQuick3DColorValueType::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8Qt3DCore5Quick22QQuick3DColorValueTypeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8Qt3DCore5Quick22QQuick3DColorValueTypeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8Qt3DCore5Quick22QQuick3DColorValueTypeE_t>.metaTypes,
    nullptr
} };

void Qt3DCore::Quick::QQuick3DColorValueType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<QQuick3DColorValueType *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 1: { QVariant _r = _t->alpha((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVariant*>(_a[0]) = std::move(_r); }  break;
        case 2: { QVariant _r = _t->lighter((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVariant*>(_a[0]) = std::move(_r); }  break;
        case 3: { QVariant _r = _t->lighter();
            if (_a[0]) *reinterpret_cast<QVariant*>(_a[0]) = std::move(_r); }  break;
        case 4: { QVariant _r = _t->darker((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVariant*>(_a[0]) = std::move(_r); }  break;
        case 5: { QVariant _r = _t->darker();
            if (_a[0]) *reinterpret_cast<QVariant*>(_a[0]) = std::move(_r); }  break;
        case 6: { QVariant _r = _t->tint((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVariant*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<qreal*>(_v) = _t->r(); break;
        case 1: *reinterpret_cast<qreal*>(_v) = _t->g(); break;
        case 2: *reinterpret_cast<qreal*>(_v) = _t->b(); break;
        case 3: *reinterpret_cast<qreal*>(_v) = _t->a(); break;
        case 4: *reinterpret_cast<qreal*>(_v) = _t->hsvHue(); break;
        case 5: *reinterpret_cast<qreal*>(_v) = _t->hsvSaturation(); break;
        case 6: *reinterpret_cast<qreal*>(_v) = _t->hsvValue(); break;
        case 7: *reinterpret_cast<qreal*>(_v) = _t->hslHue(); break;
        case 8: *reinterpret_cast<qreal*>(_v) = _t->hslSaturation(); break;
        case 9: *reinterpret_cast<qreal*>(_v) = _t->hslLightness(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->isValid(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setR(*reinterpret_cast<qreal*>(_v)); break;
        case 1: _t->setG(*reinterpret_cast<qreal*>(_v)); break;
        case 2: _t->setB(*reinterpret_cast<qreal*>(_v)); break;
        case 3: _t->setA(*reinterpret_cast<qreal*>(_v)); break;
        case 4: _t->setHsvHue(*reinterpret_cast<qreal*>(_v)); break;
        case 5: _t->setHsvSaturation(*reinterpret_cast<qreal*>(_v)); break;
        case 6: _t->setHsvValue(*reinterpret_cast<qreal*>(_v)); break;
        case 7: _t->setHslHue(*reinterpret_cast<qreal*>(_v)); break;
        case 8: _t->setHslSaturation(*reinterpret_cast<qreal*>(_v)); break;
        case 9: _t->setHslLightness(*reinterpret_cast<qreal*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN8Qt3DCore5Quick26QQuick3DMatrix4x4ValueTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto Qt3DCore::Quick::QQuick3DMatrix4x4ValueType::qt_create_metaobjectdata<qt_meta_tag_ZN8Qt3DCore5Quick26QQuick3DMatrix4x4ValueTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Qt3DCore::Quick::QQuick3DMatrix4x4ValueType",
        "QML.AddedInVersion",
        "512",
        "QML.Foreign",
        "QMatrix4x4",
        "QML.Element",
        "matrix4x4",
        "QML.Extended",
        "QQuick3DMatrix4x4ValueType",
        "translate",
        "",
        "QVector3D",
        "t",
        "rotate",
        "angle",
        "axis",
        "scale",
        "s",
        "sx",
        "sy",
        "sz",
        "lookAt",
        "eye",
        "center",
        "up",
        "times",
        "m",
        "QVector4D",
        "vec",
        "factor",
        "plus",
        "minus",
        "row",
        "n",
        "column",
        "determinant",
        "inverted",
        "transposed",
        "fuzzyEquals",
        "epsilon",
        "m11",
        "m12",
        "m13",
        "m14",
        "m21",
        "m22",
        "m23",
        "m24",
        "m31",
        "m32",
        "m33",
        "m34",
        "m41",
        "m42",
        "m43",
        "m44"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'translate'
        QtMocHelpers::MethodData<void(const QVector3D &)>(9, 10, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 12 },
        }}),
        // Method 'rotate'
        QtMocHelpers::MethodData<void(float, const QVector3D &)>(13, 10, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 14 }, { 0x80000000 | 11, 15 },
        }}),
        // Method 'scale'
        QtMocHelpers::MethodData<void(float)>(16, 10, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 17 },
        }}),
        // Method 'scale'
        QtMocHelpers::MethodData<void(float, float, float)>(16, 10, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 18 }, { QMetaType::Float, 19 }, { QMetaType::Float, 20 },
        }}),
        // Method 'scale'
        QtMocHelpers::MethodData<void(const QVector3D &)>(16, 10, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 17 },
        }}),
        // Method 'lookAt'
        QtMocHelpers::MethodData<void(const QVector3D &, const QVector3D &, const QVector3D &)>(21, 10, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 22 }, { 0x80000000 | 11, 23 }, { 0x80000000 | 11, 24 },
        }}),
        // Method 'times'
        QtMocHelpers::MethodData<QMatrix4x4(const QMatrix4x4 &) const>(25, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { 0x80000000 | 4, 26 },
        }}),
        // Method 'times'
        QtMocHelpers::MethodData<QVector4D(const QVector4D &) const>(25, 10, QMC::AccessPublic, 0x80000000 | 27, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Method 'times'
        QtMocHelpers::MethodData<QVector3D(const QVector3D &) const>(25, 10, QMC::AccessPublic, 0x80000000 | 11, {{
            { 0x80000000 | 11, 28 },
        }}),
        // Method 'times'
        QtMocHelpers::MethodData<QMatrix4x4(qreal) const>(25, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::QReal, 29 },
        }}),
        // Method 'plus'
        QtMocHelpers::MethodData<QMatrix4x4(const QMatrix4x4 &) const>(30, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { 0x80000000 | 4, 26 },
        }}),
        // Method 'minus'
        QtMocHelpers::MethodData<QMatrix4x4(const QMatrix4x4 &) const>(31, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { 0x80000000 | 4, 26 },
        }}),
        // Method 'row'
        QtMocHelpers::MethodData<QVector4D(int) const>(32, 10, QMC::AccessPublic, 0x80000000 | 27, {{
            { QMetaType::Int, 33 },
        }}),
        // Method 'column'
        QtMocHelpers::MethodData<QVector4D(int) const>(34, 10, QMC::AccessPublic, 0x80000000 | 27, {{
            { QMetaType::Int, 26 },
        }}),
        // Method 'determinant'
        QtMocHelpers::MethodData<qreal() const>(35, 10, QMC::AccessPublic, QMetaType::QReal),
        // Method 'inverted'
        QtMocHelpers::MethodData<QMatrix4x4() const>(36, 10, QMC::AccessPublic, 0x80000000 | 4),
        // Method 'transposed'
        QtMocHelpers::MethodData<QMatrix4x4() const>(37, 10, QMC::AccessPublic, 0x80000000 | 4),
        // Method 'fuzzyEquals'
        QtMocHelpers::MethodData<bool(const QMatrix4x4 &, qreal) const>(38, 10, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 4, 26 }, { QMetaType::QReal, 39 },
        }}),
        // Method 'fuzzyEquals'
        QtMocHelpers::MethodData<bool(const QMatrix4x4 &) const>(38, 10, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 4, 26 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'm11'
        QtMocHelpers::PropertyData<qreal>(40, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'm12'
        QtMocHelpers::PropertyData<qreal>(41, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'm13'
        QtMocHelpers::PropertyData<qreal>(42, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'm14'
        QtMocHelpers::PropertyData<qreal>(43, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'm21'
        QtMocHelpers::PropertyData<qreal>(44, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'm22'
        QtMocHelpers::PropertyData<qreal>(45, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'm23'
        QtMocHelpers::PropertyData<qreal>(46, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'm24'
        QtMocHelpers::PropertyData<qreal>(47, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'm31'
        QtMocHelpers::PropertyData<qreal>(48, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'm32'
        QtMocHelpers::PropertyData<qreal>(49, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'm33'
        QtMocHelpers::PropertyData<qreal>(50, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'm34'
        QtMocHelpers::PropertyData<qreal>(51, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'm41'
        QtMocHelpers::PropertyData<qreal>(52, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'm42'
        QtMocHelpers::PropertyData<qreal>(53, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'm43'
        QtMocHelpers::PropertyData<qreal>(54, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'm44'
        QtMocHelpers::PropertyData<qreal>(55, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QQuick3DMatrix4x4ValueType, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Qt3DCore::Quick::QQuick3DMatrix4x4ValueType::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8Qt3DCore5Quick26QQuick3DMatrix4x4ValueTypeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8Qt3DCore5Quick26QQuick3DMatrix4x4ValueTypeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8Qt3DCore5Quick26QQuick3DMatrix4x4ValueTypeE_t>.metaTypes,
    nullptr
} };

void Qt3DCore::Quick::QQuick3DMatrix4x4ValueType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<QQuick3DMatrix4x4ValueType *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->translate((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1]))); break;
        case 1: _t->rotate((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[2]))); break;
        case 2: _t->scale((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 3: _t->scale((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[3]))); break;
        case 4: _t->scale((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1]))); break;
        case 5: _t->lookAt((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[3]))); break;
        case 6: { QMatrix4x4 _r = _t->times((*reinterpret_cast<std::add_pointer_t<QMatrix4x4>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QMatrix4x4*>(_a[0]) = std::move(_r); }  break;
        case 7: { QVector4D _r = _t->times((*reinterpret_cast<std::add_pointer_t<QVector4D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector4D*>(_a[0]) = std::move(_r); }  break;
        case 8: { QVector3D _r = _t->times((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector3D*>(_a[0]) = std::move(_r); }  break;
        case 9: { QMatrix4x4 _r = _t->times((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QMatrix4x4*>(_a[0]) = std::move(_r); }  break;
        case 10: { QMatrix4x4 _r = _t->plus((*reinterpret_cast<std::add_pointer_t<QMatrix4x4>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QMatrix4x4*>(_a[0]) = std::move(_r); }  break;
        case 11: { QMatrix4x4 _r = _t->minus((*reinterpret_cast<std::add_pointer_t<QMatrix4x4>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QMatrix4x4*>(_a[0]) = std::move(_r); }  break;
        case 12: { QVector4D _r = _t->row((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector4D*>(_a[0]) = std::move(_r); }  break;
        case 13: { QVector4D _r = _t->column((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector4D*>(_a[0]) = std::move(_r); }  break;
        case 14: { qreal _r = _t->determinant();
            if (_a[0]) *reinterpret_cast<qreal*>(_a[0]) = std::move(_r); }  break;
        case 15: { QMatrix4x4 _r = _t->inverted();
            if (_a[0]) *reinterpret_cast<QMatrix4x4*>(_a[0]) = std::move(_r); }  break;
        case 16: { QMatrix4x4 _r = _t->transposed();
            if (_a[0]) *reinterpret_cast<QMatrix4x4*>(_a[0]) = std::move(_r); }  break;
        case 17: { bool _r = _t->fuzzyEquals((*reinterpret_cast<std::add_pointer_t<QMatrix4x4>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qreal>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 18: { bool _r = _t->fuzzyEquals((*reinterpret_cast<std::add_pointer_t<QMatrix4x4>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<qreal*>(_v) = _t->m11(); break;
        case 1: *reinterpret_cast<qreal*>(_v) = _t->m12(); break;
        case 2: *reinterpret_cast<qreal*>(_v) = _t->m13(); break;
        case 3: *reinterpret_cast<qreal*>(_v) = _t->m14(); break;
        case 4: *reinterpret_cast<qreal*>(_v) = _t->m21(); break;
        case 5: *reinterpret_cast<qreal*>(_v) = _t->m22(); break;
        case 6: *reinterpret_cast<qreal*>(_v) = _t->m23(); break;
        case 7: *reinterpret_cast<qreal*>(_v) = _t->m24(); break;
        case 8: *reinterpret_cast<qreal*>(_v) = _t->m31(); break;
        case 9: *reinterpret_cast<qreal*>(_v) = _t->m32(); break;
        case 10: *reinterpret_cast<qreal*>(_v) = _t->m33(); break;
        case 11: *reinterpret_cast<qreal*>(_v) = _t->m34(); break;
        case 12: *reinterpret_cast<qreal*>(_v) = _t->m41(); break;
        case 13: *reinterpret_cast<qreal*>(_v) = _t->m42(); break;
        case 14: *reinterpret_cast<qreal*>(_v) = _t->m43(); break;
        case 15: *reinterpret_cast<qreal*>(_v) = _t->m44(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setM11(*reinterpret_cast<qreal*>(_v)); break;
        case 1: _t->setM12(*reinterpret_cast<qreal*>(_v)); break;
        case 2: _t->setM13(*reinterpret_cast<qreal*>(_v)); break;
        case 3: _t->setM14(*reinterpret_cast<qreal*>(_v)); break;
        case 4: _t->setM21(*reinterpret_cast<qreal*>(_v)); break;
        case 5: _t->setM22(*reinterpret_cast<qreal*>(_v)); break;
        case 6: _t->setM23(*reinterpret_cast<qreal*>(_v)); break;
        case 7: _t->setM24(*reinterpret_cast<qreal*>(_v)); break;
        case 8: _t->setM31(*reinterpret_cast<qreal*>(_v)); break;
        case 9: _t->setM32(*reinterpret_cast<qreal*>(_v)); break;
        case 10: _t->setM33(*reinterpret_cast<qreal*>(_v)); break;
        case 11: _t->setM34(*reinterpret_cast<qreal*>(_v)); break;
        case 12: _t->setM41(*reinterpret_cast<qreal*>(_v)); break;
        case 13: _t->setM42(*reinterpret_cast<qreal*>(_v)); break;
        case 14: _t->setM43(*reinterpret_cast<qreal*>(_v)); break;
        case 15: _t->setM44(*reinterpret_cast<qreal*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN8Qt3DCore5Quick25QQuick3DVector2DValueTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto Qt3DCore::Quick::QQuick3DVector2DValueType::qt_create_metaobjectdata<qt_meta_tag_ZN8Qt3DCore5Quick25QQuick3DVector2DValueTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Qt3DCore::Quick::QQuick3DVector2DValueType",
        "QML.AddedInVersion",
        "512",
        "QML.Foreign",
        "QVector2D",
        "QML.Element",
        "vector2d",
        "QML.Extended",
        "QQuick3DVector2DValueType",
        "toString",
        "",
        "dotProduct",
        "vec",
        "times",
        "scalar",
        "plus",
        "minus",
        "normalized",
        "length",
        "toVector3d",
        "QVector3D",
        "toVector4d",
        "QVector4D",
        "fuzzyEquals",
        "epsilon",
        "x",
        "y"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(9, 10, QMC::AccessPublic, QMetaType::QString),
        // Method 'dotProduct'
        QtMocHelpers::MethodData<qreal(const QVector2D &) const>(11, 10, QMC::AccessPublic, QMetaType::QReal, {{
            { 0x80000000 | 4, 12 },
        }}),
        // Method 'times'
        QtMocHelpers::MethodData<QVector2D(const QVector2D &) const>(13, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { 0x80000000 | 4, 12 },
        }}),
        // Method 'times'
        QtMocHelpers::MethodData<QVector2D(qreal) const>(13, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::QReal, 14 },
        }}),
        // Method 'plus'
        QtMocHelpers::MethodData<QVector2D(const QVector2D &) const>(15, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { 0x80000000 | 4, 12 },
        }}),
        // Method 'minus'
        QtMocHelpers::MethodData<QVector2D(const QVector2D &) const>(16, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { 0x80000000 | 4, 12 },
        }}),
        // Method 'normalized'
        QtMocHelpers::MethodData<QVector2D() const>(17, 10, QMC::AccessPublic, 0x80000000 | 4),
        // Method 'length'
        QtMocHelpers::MethodData<qreal() const>(18, 10, QMC::AccessPublic, QMetaType::QReal),
        // Method 'toVector3d'
        QtMocHelpers::MethodData<QVector3D() const>(19, 10, QMC::AccessPublic, 0x80000000 | 20),
        // Method 'toVector4d'
        QtMocHelpers::MethodData<QVector4D() const>(21, 10, QMC::AccessPublic, 0x80000000 | 22),
        // Method 'fuzzyEquals'
        QtMocHelpers::MethodData<bool(const QVector2D &, qreal) const>(23, 10, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 4, 12 }, { QMetaType::QReal, 24 },
        }}),
        // Method 'fuzzyEquals'
        QtMocHelpers::MethodData<bool(const QVector2D &) const>(23, 10, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 4, 12 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'x'
        QtMocHelpers::PropertyData<qreal>(25, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'y'
        QtMocHelpers::PropertyData<qreal>(26, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QQuick3DVector2DValueType, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Qt3DCore::Quick::QQuick3DVector2DValueType::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8Qt3DCore5Quick25QQuick3DVector2DValueTypeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8Qt3DCore5Quick25QQuick3DVector2DValueTypeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8Qt3DCore5Quick25QQuick3DVector2DValueTypeE_t>.metaTypes,
    nullptr
} };

void Qt3DCore::Quick::QQuick3DVector2DValueType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<QQuick3DVector2DValueType *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 1: { qreal _r = _t->dotProduct((*reinterpret_cast<std::add_pointer_t<QVector2D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<qreal*>(_a[0]) = std::move(_r); }  break;
        case 2: { QVector2D _r = _t->times((*reinterpret_cast<std::add_pointer_t<QVector2D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector2D*>(_a[0]) = std::move(_r); }  break;
        case 3: { QVector2D _r = _t->times((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector2D*>(_a[0]) = std::move(_r); }  break;
        case 4: { QVector2D _r = _t->plus((*reinterpret_cast<std::add_pointer_t<QVector2D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector2D*>(_a[0]) = std::move(_r); }  break;
        case 5: { QVector2D _r = _t->minus((*reinterpret_cast<std::add_pointer_t<QVector2D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector2D*>(_a[0]) = std::move(_r); }  break;
        case 6: { QVector2D _r = _t->normalized();
            if (_a[0]) *reinterpret_cast<QVector2D*>(_a[0]) = std::move(_r); }  break;
        case 7: { qreal _r = _t->length();
            if (_a[0]) *reinterpret_cast<qreal*>(_a[0]) = std::move(_r); }  break;
        case 8: { QVector3D _r = _t->toVector3d();
            if (_a[0]) *reinterpret_cast<QVector3D*>(_a[0]) = std::move(_r); }  break;
        case 9: { QVector4D _r = _t->toVector4d();
            if (_a[0]) *reinterpret_cast<QVector4D*>(_a[0]) = std::move(_r); }  break;
        case 10: { bool _r = _t->fuzzyEquals((*reinterpret_cast<std::add_pointer_t<QVector2D>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qreal>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 11: { bool _r = _t->fuzzyEquals((*reinterpret_cast<std::add_pointer_t<QVector2D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<qreal*>(_v) = _t->x(); break;
        case 1: *reinterpret_cast<qreal*>(_v) = _t->y(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setX(*reinterpret_cast<qreal*>(_v)); break;
        case 1: _t->setY(*reinterpret_cast<qreal*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN8Qt3DCore5Quick25QQuick3DVector3DValueTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto Qt3DCore::Quick::QQuick3DVector3DValueType::qt_create_metaobjectdata<qt_meta_tag_ZN8Qt3DCore5Quick25QQuick3DVector3DValueTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Qt3DCore::Quick::QQuick3DVector3DValueType",
        "QML.AddedInVersion",
        "512",
        "QML.Foreign",
        "QVector3D",
        "QML.Element",
        "vector3d",
        "QML.Extended",
        "QQuick3DVector3DValueType",
        "toString",
        "",
        "crossProduct",
        "vec",
        "dotProduct",
        "times",
        "QMatrix4x4",
        "m",
        "scalar",
        "plus",
        "minus",
        "normalized",
        "length",
        "toVector2d",
        "QVector2D",
        "toVector4d",
        "QVector4D",
        "fuzzyEquals",
        "epsilon",
        "x",
        "y",
        "z"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(9, 10, QMC::AccessPublic, QMetaType::QString),
        // Method 'crossProduct'
        QtMocHelpers::MethodData<QVector3D(const QVector3D &) const>(11, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { 0x80000000 | 4, 12 },
        }}),
        // Method 'dotProduct'
        QtMocHelpers::MethodData<qreal(const QVector3D &) const>(13, 10, QMC::AccessPublic, QMetaType::QReal, {{
            { 0x80000000 | 4, 12 },
        }}),
        // Method 'times'
        QtMocHelpers::MethodData<QVector3D(const QMatrix4x4 &) const>(14, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { 0x80000000 | 15, 16 },
        }}),
        // Method 'times'
        QtMocHelpers::MethodData<QVector3D(const QVector3D &) const>(14, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { 0x80000000 | 4, 12 },
        }}),
        // Method 'times'
        QtMocHelpers::MethodData<QVector3D(qreal) const>(14, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::QReal, 17 },
        }}),
        // Method 'plus'
        QtMocHelpers::MethodData<QVector3D(const QVector3D &) const>(18, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { 0x80000000 | 4, 12 },
        }}),
        // Method 'minus'
        QtMocHelpers::MethodData<QVector3D(const QVector3D &) const>(19, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { 0x80000000 | 4, 12 },
        }}),
        // Method 'normalized'
        QtMocHelpers::MethodData<QVector3D() const>(20, 10, QMC::AccessPublic, 0x80000000 | 4),
        // Method 'length'
        QtMocHelpers::MethodData<qreal() const>(21, 10, QMC::AccessPublic, QMetaType::QReal),
        // Method 'toVector2d'
        QtMocHelpers::MethodData<QVector2D() const>(22, 10, QMC::AccessPublic, 0x80000000 | 23),
        // Method 'toVector4d'
        QtMocHelpers::MethodData<QVector4D() const>(24, 10, QMC::AccessPublic, 0x80000000 | 25),
        // Method 'fuzzyEquals'
        QtMocHelpers::MethodData<bool(const QVector3D &, qreal) const>(26, 10, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 4, 12 }, { QMetaType::QReal, 27 },
        }}),
        // Method 'fuzzyEquals'
        QtMocHelpers::MethodData<bool(const QVector3D &) const>(26, 10, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 4, 12 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'x'
        QtMocHelpers::PropertyData<qreal>(28, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'y'
        QtMocHelpers::PropertyData<qreal>(29, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'z'
        QtMocHelpers::PropertyData<qreal>(30, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QQuick3DVector3DValueType, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Qt3DCore::Quick::QQuick3DVector3DValueType::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8Qt3DCore5Quick25QQuick3DVector3DValueTypeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8Qt3DCore5Quick25QQuick3DVector3DValueTypeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8Qt3DCore5Quick25QQuick3DVector3DValueTypeE_t>.metaTypes,
    nullptr
} };

void Qt3DCore::Quick::QQuick3DVector3DValueType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<QQuick3DVector3DValueType *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 1: { QVector3D _r = _t->crossProduct((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector3D*>(_a[0]) = std::move(_r); }  break;
        case 2: { qreal _r = _t->dotProduct((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<qreal*>(_a[0]) = std::move(_r); }  break;
        case 3: { QVector3D _r = _t->times((*reinterpret_cast<std::add_pointer_t<QMatrix4x4>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector3D*>(_a[0]) = std::move(_r); }  break;
        case 4: { QVector3D _r = _t->times((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector3D*>(_a[0]) = std::move(_r); }  break;
        case 5: { QVector3D _r = _t->times((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector3D*>(_a[0]) = std::move(_r); }  break;
        case 6: { QVector3D _r = _t->plus((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector3D*>(_a[0]) = std::move(_r); }  break;
        case 7: { QVector3D _r = _t->minus((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector3D*>(_a[0]) = std::move(_r); }  break;
        case 8: { QVector3D _r = _t->normalized();
            if (_a[0]) *reinterpret_cast<QVector3D*>(_a[0]) = std::move(_r); }  break;
        case 9: { qreal _r = _t->length();
            if (_a[0]) *reinterpret_cast<qreal*>(_a[0]) = std::move(_r); }  break;
        case 10: { QVector2D _r = _t->toVector2d();
            if (_a[0]) *reinterpret_cast<QVector2D*>(_a[0]) = std::move(_r); }  break;
        case 11: { QVector4D _r = _t->toVector4d();
            if (_a[0]) *reinterpret_cast<QVector4D*>(_a[0]) = std::move(_r); }  break;
        case 12: { bool _r = _t->fuzzyEquals((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qreal>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 13: { bool _r = _t->fuzzyEquals((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<qreal*>(_v) = _t->x(); break;
        case 1: *reinterpret_cast<qreal*>(_v) = _t->y(); break;
        case 2: *reinterpret_cast<qreal*>(_v) = _t->z(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setX(*reinterpret_cast<qreal*>(_v)); break;
        case 1: _t->setY(*reinterpret_cast<qreal*>(_v)); break;
        case 2: _t->setZ(*reinterpret_cast<qreal*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN8Qt3DCore5Quick25QQuick3DVector4DValueTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto Qt3DCore::Quick::QQuick3DVector4DValueType::qt_create_metaobjectdata<qt_meta_tag_ZN8Qt3DCore5Quick25QQuick3DVector4DValueTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Qt3DCore::Quick::QQuick3DVector4DValueType",
        "QML.AddedInVersion",
        "512",
        "QML.Foreign",
        "QVector4D",
        "QML.Element",
        "vector4d",
        "QML.Extended",
        "QQuick3DVector4DValueType",
        "toString",
        "",
        "dotProduct",
        "vec",
        "times",
        "QMatrix4x4",
        "m",
        "scalar",
        "plus",
        "minus",
        "normalized",
        "length",
        "toVector2d",
        "QVector2D",
        "toVector3d",
        "QVector3D",
        "fuzzyEquals",
        "epsilon",
        "x",
        "y",
        "z",
        "w"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(9, 10, QMC::AccessPublic, QMetaType::QString),
        // Method 'dotProduct'
        QtMocHelpers::MethodData<qreal(const QVector4D &) const>(11, 10, QMC::AccessPublic, QMetaType::QReal, {{
            { 0x80000000 | 4, 12 },
        }}),
        // Method 'times'
        QtMocHelpers::MethodData<QVector4D(const QVector4D &) const>(13, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { 0x80000000 | 4, 12 },
        }}),
        // Method 'times'
        QtMocHelpers::MethodData<QVector4D(const QMatrix4x4 &) const>(13, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { 0x80000000 | 14, 15 },
        }}),
        // Method 'times'
        QtMocHelpers::MethodData<QVector4D(qreal) const>(13, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::QReal, 16 },
        }}),
        // Method 'plus'
        QtMocHelpers::MethodData<QVector4D(const QVector4D &) const>(17, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { 0x80000000 | 4, 12 },
        }}),
        // Method 'minus'
        QtMocHelpers::MethodData<QVector4D(const QVector4D &) const>(18, 10, QMC::AccessPublic, 0x80000000 | 4, {{
            { 0x80000000 | 4, 12 },
        }}),
        // Method 'normalized'
        QtMocHelpers::MethodData<QVector4D() const>(19, 10, QMC::AccessPublic, 0x80000000 | 4),
        // Method 'length'
        QtMocHelpers::MethodData<qreal() const>(20, 10, QMC::AccessPublic, QMetaType::QReal),
        // Method 'toVector2d'
        QtMocHelpers::MethodData<QVector2D() const>(21, 10, QMC::AccessPublic, 0x80000000 | 22),
        // Method 'toVector3d'
        QtMocHelpers::MethodData<QVector3D() const>(23, 10, QMC::AccessPublic, 0x80000000 | 24),
        // Method 'fuzzyEquals'
        QtMocHelpers::MethodData<bool(const QVector4D &, qreal) const>(25, 10, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 4, 12 }, { QMetaType::QReal, 26 },
        }}),
        // Method 'fuzzyEquals'
        QtMocHelpers::MethodData<bool(const QVector4D &) const>(25, 10, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 4, 12 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'x'
        QtMocHelpers::PropertyData<qreal>(27, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'y'
        QtMocHelpers::PropertyData<qreal>(28, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'z'
        QtMocHelpers::PropertyData<qreal>(29, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
        // property 'w'
        QtMocHelpers::PropertyData<qreal>(30, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QQuick3DVector4DValueType, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Qt3DCore::Quick::QQuick3DVector4DValueType::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8Qt3DCore5Quick25QQuick3DVector4DValueTypeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8Qt3DCore5Quick25QQuick3DVector4DValueTypeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8Qt3DCore5Quick25QQuick3DVector4DValueTypeE_t>.metaTypes,
    nullptr
} };

void Qt3DCore::Quick::QQuick3DVector4DValueType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<QQuick3DVector4DValueType *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 1: { qreal _r = _t->dotProduct((*reinterpret_cast<std::add_pointer_t<QVector4D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<qreal*>(_a[0]) = std::move(_r); }  break;
        case 2: { QVector4D _r = _t->times((*reinterpret_cast<std::add_pointer_t<QVector4D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector4D*>(_a[0]) = std::move(_r); }  break;
        case 3: { QVector4D _r = _t->times((*reinterpret_cast<std::add_pointer_t<QMatrix4x4>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector4D*>(_a[0]) = std::move(_r); }  break;
        case 4: { QVector4D _r = _t->times((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector4D*>(_a[0]) = std::move(_r); }  break;
        case 5: { QVector4D _r = _t->plus((*reinterpret_cast<std::add_pointer_t<QVector4D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector4D*>(_a[0]) = std::move(_r); }  break;
        case 6: { QVector4D _r = _t->minus((*reinterpret_cast<std::add_pointer_t<QVector4D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVector4D*>(_a[0]) = std::move(_r); }  break;
        case 7: { QVector4D _r = _t->normalized();
            if (_a[0]) *reinterpret_cast<QVector4D*>(_a[0]) = std::move(_r); }  break;
        case 8: { qreal _r = _t->length();
            if (_a[0]) *reinterpret_cast<qreal*>(_a[0]) = std::move(_r); }  break;
        case 9: { QVector2D _r = _t->toVector2d();
            if (_a[0]) *reinterpret_cast<QVector2D*>(_a[0]) = std::move(_r); }  break;
        case 10: { QVector3D _r = _t->toVector3d();
            if (_a[0]) *reinterpret_cast<QVector3D*>(_a[0]) = std::move(_r); }  break;
        case 11: { bool _r = _t->fuzzyEquals((*reinterpret_cast<std::add_pointer_t<QVector4D>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qreal>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 12: { bool _r = _t->fuzzyEquals((*reinterpret_cast<std::add_pointer_t<QVector4D>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<qreal*>(_v) = _t->x(); break;
        case 1: *reinterpret_cast<qreal*>(_v) = _t->y(); break;
        case 2: *reinterpret_cast<qreal*>(_v) = _t->z(); break;
        case 3: *reinterpret_cast<qreal*>(_v) = _t->w(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setX(*reinterpret_cast<qreal*>(_v)); break;
        case 1: _t->setY(*reinterpret_cast<qreal*>(_v)); break;
        case 2: _t->setZ(*reinterpret_cast<qreal*>(_v)); break;
        case 3: _t->setW(*reinterpret_cast<qreal*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN8Qt3DCore5Quick27QQuick3DQuaternionValueTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto Qt3DCore::Quick::QQuick3DQuaternionValueType::qt_create_metaobjectdata<qt_meta_tag_ZN8Qt3DCore5Quick27QQuick3DQuaternionValueTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Qt3DCore::Quick::QQuick3DQuaternionValueType",
        "QML.AddedInVersion",
        "512",
        "QML.Foreign",
        "QQuaternion",
        "QML.Element",
        "quaternion",
        "QML.Extended",
        "QQuick3DQuaternionValueType",
        "toString",
        "",
        "scalar",
        "x",
        "y",
        "z"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(9, 10, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'scalar'
        QtMocHelpers::PropertyData<qreal>(11, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'x'
        QtMocHelpers::PropertyData<qreal>(12, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'y'
        QtMocHelpers::PropertyData<qreal>(13, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'z'
        QtMocHelpers::PropertyData<qreal>(14, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QQuick3DQuaternionValueType, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Qt3DCore::Quick::QQuick3DQuaternionValueType::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8Qt3DCore5Quick27QQuick3DQuaternionValueTypeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8Qt3DCore5Quick27QQuick3DQuaternionValueTypeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8Qt3DCore5Quick27QQuick3DQuaternionValueTypeE_t>.metaTypes,
    nullptr
} };

void Qt3DCore::Quick::QQuick3DQuaternionValueType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<QQuick3DQuaternionValueType *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<qreal*>(_v) = _t->scalar(); break;
        case 1: *reinterpret_cast<qreal*>(_v) = _t->x(); break;
        case 2: *reinterpret_cast<qreal*>(_v) = _t->y(); break;
        case 3: *reinterpret_cast<qreal*>(_v) = _t->z(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setScalar(*reinterpret_cast<qreal*>(_v)); break;
        case 1: _t->setX(*reinterpret_cast<qreal*>(_v)); break;
        case 2: _t->setY(*reinterpret_cast<qreal*>(_v)); break;
        case 3: _t->setZ(*reinterpret_cast<qreal*>(_v)); break;
        default: break;
        }
    }
}
QT_WARNING_POP
