/****************************************************************************
** Meta object code from reading C++ file 'qdynamicrigidbody_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 "../../../../../qtquick3dphysics/src/quick3dphysics/qdynamicrigidbody_p.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 'qdynamicrigidbody_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_ZN17QDynamicRigidBodyE_t {};
} // unnamed namespace

template <> constexpr inline auto QDynamicRigidBody::qt_create_metaobjectdata<qt_meta_tag_ZN17QDynamicRigidBodyE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QDynamicRigidBody",
        "QML.Element",
        "DynamicRigidBody",
        "massChanged",
        "",
        "mass",
        "densityChanged",
        "density",
        "isKinematicChanged",
        "isKinematic",
        "linearAxisLockChanged",
        "angularAxisLockChanged",
        "gravityEnabledChanged",
        "massModeChanged",
        "inertiaTensorChanged",
        "centerOfMassPositionChanged",
        "centerOfMassRotationChanged",
        "inertiaMatrixChanged",
        "kinematicPositionChanged",
        "QVector3D",
        "kinematicPosition",
        "kinematicRotationChanged",
        "QQuaternion",
        "kinematicRotation",
        "kinematicEulerRotationChanged",
        "kinematicEulerRotation",
        "kinematicPivotChanged",
        "kinematicPivot",
        "isSleepingChanged",
        "isSleeping",
        "applyCentralForce",
        "force",
        "applyForce",
        "position",
        "applyTorque",
        "torque",
        "applyCentralImpulse",
        "impulse",
        "applyImpulse",
        "applyTorqueImpulse",
        "setAngularVelocity",
        "angularVelocity",
        "setLinearVelocity",
        "linearVelocity",
        "reset",
        "eulerRotation",
        "linearAxisLock",
        "AxisLock",
        "angularAxisLock",
        "gravityEnabled",
        "massMode",
        "MassMode",
        "inertiaTensor",
        "centerOfMassPosition",
        "centerOfMassRotation",
        "inertiaMatrix",
        "QList<float>",
        "DefaultDensity",
        "CustomDensity",
        "Mass",
        "MassAndInertiaTensor",
        "MassAndInertiaMatrix",
        "LockNone",
        "LockX",
        "LockY",
        "LockZ"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'massChanged'
        QtMocHelpers::SignalData<void(float)>(3, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 5 },
        }}),
        // Signal 'densityChanged'
        QtMocHelpers::SignalData<void(float)>(6, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 7 },
        }}),
        // Signal 'isKinematicChanged'
        QtMocHelpers::SignalData<void(bool)>(8, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 9 },
        }}),
        // Signal 'linearAxisLockChanged'
        QtMocHelpers::RevisionedSignalData<void()>(10, 4, QMC::AccessPublic, 0x605, QMetaType::Void),
        // Signal 'angularAxisLockChanged'
        QtMocHelpers::RevisionedSignalData<void()>(11, 4, QMC::AccessPublic, 0x605, QMetaType::Void),
        // Signal 'gravityEnabledChanged'
        QtMocHelpers::SignalData<void()>(12, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'massModeChanged'
        QtMocHelpers::SignalData<void()>(13, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'inertiaTensorChanged'
        QtMocHelpers::SignalData<void()>(14, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'centerOfMassPositionChanged'
        QtMocHelpers::SignalData<void()>(15, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'centerOfMassRotationChanged'
        QtMocHelpers::SignalData<void()>(16, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'inertiaMatrixChanged'
        QtMocHelpers::SignalData<void()>(17, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'kinematicPositionChanged'
        QtMocHelpers::RevisionedSignalData<void(const QVector3D &)>(18, 4, QMC::AccessPublic, 0x605, QMetaType::Void, {{
            { 0x80000000 | 19, 20 },
        }}),
        // Signal 'kinematicRotationChanged'
        QtMocHelpers::RevisionedSignalData<void(const QQuaternion &)>(21, 4, QMC::AccessPublic, 0x605, QMetaType::Void, {{
            { 0x80000000 | 22, 23 },
        }}),
        // Signal 'kinematicEulerRotationChanged'
        QtMocHelpers::RevisionedSignalData<void(const QVector3D &)>(24, 4, QMC::AccessPublic, 0x605, QMetaType::Void, {{
            { 0x80000000 | 19, 25 },
        }}),
        // Signal 'kinematicPivotChanged'
        QtMocHelpers::RevisionedSignalData<void(const QVector3D &)>(26, 4, QMC::AccessPublic, 0x605, QMetaType::Void, {{
            { 0x80000000 | 19, 27 },
        }}),
        // Signal 'isSleepingChanged'
        QtMocHelpers::RevisionedSignalData<void(bool)>(28, 4, QMC::AccessPublic, 0x609, QMetaType::Void, {{
            { QMetaType::Bool, 29 },
        }}),
        // Method 'applyCentralForce'
        QtMocHelpers::MethodData<void(const QVector3D &)>(30, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 19, 31 },
        }}),
        // Method 'applyForce'
        QtMocHelpers::MethodData<void(const QVector3D &, const QVector3D &)>(32, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 19, 31 }, { 0x80000000 | 19, 33 },
        }}),
        // Method 'applyTorque'
        QtMocHelpers::MethodData<void(const QVector3D &)>(34, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 19, 35 },
        }}),
        // Method 'applyCentralImpulse'
        QtMocHelpers::MethodData<void(const QVector3D &)>(36, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 19, 37 },
        }}),
        // Method 'applyImpulse'
        QtMocHelpers::MethodData<void(const QVector3D &, const QVector3D &)>(38, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 19, 37 }, { 0x80000000 | 19, 33 },
        }}),
        // Method 'applyTorqueImpulse'
        QtMocHelpers::MethodData<void(const QVector3D &)>(39, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 19, 37 },
        }}),
        // Method 'setAngularVelocity'
        QtMocHelpers::MethodData<void(const QVector3D &)>(40, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 19, 41 },
        }}),
        // Method 'setLinearVelocity'
        QtMocHelpers::MethodData<void(const QVector3D &)>(42, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 19, 43 },
        }}),
        // Method 'reset'
        QtMocHelpers::MethodData<void(const QVector3D &, const QVector3D &)>(44, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 19, 33 }, { 0x80000000 | 19, 45 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'mass'
        QtMocHelpers::PropertyData<float>(5, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
        // property 'density'
        QtMocHelpers::PropertyData<float>(7, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'linearAxisLock'
        QtMocHelpers::PropertyData<enum AxisLock>(46, 0x80000000 | 47, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 3, 0x605),
        // property 'angularAxisLock'
        QtMocHelpers::PropertyData<enum AxisLock>(48, 0x80000000 | 47, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 4, 0x605),
        // property 'isKinematic'
        QtMocHelpers::PropertyData<bool>(9, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'gravityEnabled'
        QtMocHelpers::PropertyData<bool>(49, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 5),
        // property 'massMode'
        QtMocHelpers::PropertyData<enum MassMode>(50, 0x80000000 | 51, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 6),
        // property 'inertiaTensor'
        QtMocHelpers::PropertyData<QVector3D>(52, 0x80000000 | 19, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 7),
        // property 'centerOfMassPosition'
        QtMocHelpers::PropertyData<QVector3D>(53, 0x80000000 | 19, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 8),
        // property 'centerOfMassRotation'
        QtMocHelpers::PropertyData<QQuaternion>(54, 0x80000000 | 22, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 9),
        // property 'inertiaMatrix'
        QtMocHelpers::PropertyData<QList<float>>(55, 0x80000000 | 56, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 10),
        // property 'kinematicPosition'
        QtMocHelpers::PropertyData<QVector3D>(20, 0x80000000 | 19, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 11, 0x605),
        // property 'kinematicEulerRotation'
        QtMocHelpers::PropertyData<QVector3D>(25, 0x80000000 | 19, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 13, 0x605),
        // property 'kinematicRotation'
        QtMocHelpers::PropertyData<QQuaternion>(23, 0x80000000 | 22, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 12, 0x605),
        // property 'kinematicPivot'
        QtMocHelpers::PropertyData<QVector3D>(27, 0x80000000 | 19, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 14, 0x605),
        // property 'isSleeping'
        QtMocHelpers::PropertyData<bool>(29, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 15, 0x609),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'MassMode'
        QtMocHelpers::EnumData<enum MassMode>(51, 51, QMC::EnumIsScoped).add({
            {   57, MassMode::DefaultDensity },
            {   58, MassMode::CustomDensity },
            {   59, MassMode::Mass },
            {   60, MassMode::MassAndInertiaTensor },
            {   61, MassMode::MassAndInertiaMatrix },
        }),
        // enum 'AxisLock'
        QtMocHelpers::EnumData<enum AxisLock>(47, 47, QMC::EnumFlags{}).add({
            {   62, AxisLock::LockNone },
            {   63, AxisLock::LockX },
            {   64, AxisLock::LockY },
            {   65, AxisLock::LockZ },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<QDynamicRigidBody, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QDynamicRigidBody::staticMetaObject = { {
    QMetaObject::SuperData::link<QAbstractPhysicsBody::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QDynamicRigidBodyE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QDynamicRigidBodyE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QDynamicRigidBodyE_t>.metaTypes,
    nullptr
} };

void QDynamicRigidBody::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QDynamicRigidBody *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->massChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 1: _t->densityChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 2: _t->isKinematicChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 3: _t->linearAxisLockChanged(); break;
        case 4: _t->angularAxisLockChanged(); break;
        case 5: _t->gravityEnabledChanged(); break;
        case 6: _t->massModeChanged(); break;
        case 7: _t->inertiaTensorChanged(); break;
        case 8: _t->centerOfMassPositionChanged(); break;
        case 9: _t->centerOfMassRotationChanged(); break;
        case 10: _t->inertiaMatrixChanged(); break;
        case 11: _t->kinematicPositionChanged((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1]))); break;
        case 12: _t->kinematicRotationChanged((*reinterpret_cast<std::add_pointer_t<QQuaternion>>(_a[1]))); break;
        case 13: _t->kinematicEulerRotationChanged((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1]))); break;
        case 14: _t->kinematicPivotChanged((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1]))); break;
        case 15: _t->isSleepingChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 16: _t->applyCentralForce((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1]))); break;
        case 17: _t->applyForce((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[2]))); break;
        case 18: _t->applyTorque((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1]))); break;
        case 19: _t->applyCentralImpulse((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1]))); break;
        case 20: _t->applyImpulse((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[2]))); break;
        case 21: _t->applyTorqueImpulse((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1]))); break;
        case 22: _t->setAngularVelocity((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1]))); break;
        case 23: _t->setLinearVelocity((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1]))); break;
        case 24: _t->reset((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[2]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (QDynamicRigidBody::*)(float )>(_a, &QDynamicRigidBody::massChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (QDynamicRigidBody::*)(float )>(_a, &QDynamicRigidBody::densityChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (QDynamicRigidBody::*)(bool )>(_a, &QDynamicRigidBody::isKinematicChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (QDynamicRigidBody::*)()>(_a, &QDynamicRigidBody::linearAxisLockChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (QDynamicRigidBody::*)()>(_a, &QDynamicRigidBody::angularAxisLockChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (QDynamicRigidBody::*)()>(_a, &QDynamicRigidBody::gravityEnabledChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (QDynamicRigidBody::*)()>(_a, &QDynamicRigidBody::massModeChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (QDynamicRigidBody::*)()>(_a, &QDynamicRigidBody::inertiaTensorChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (QDynamicRigidBody::*)()>(_a, &QDynamicRigidBody::centerOfMassPositionChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (QDynamicRigidBody::*)()>(_a, &QDynamicRigidBody::centerOfMassRotationChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (QDynamicRigidBody::*)()>(_a, &QDynamicRigidBody::inertiaMatrixChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (QDynamicRigidBody::*)(const QVector3D & )>(_a, &QDynamicRigidBody::kinematicPositionChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (QDynamicRigidBody::*)(const QQuaternion & )>(_a, &QDynamicRigidBody::kinematicRotationChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (QDynamicRigidBody::*)(const QVector3D & )>(_a, &QDynamicRigidBody::kinematicEulerRotationChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (QDynamicRigidBody::*)(const QVector3D & )>(_a, &QDynamicRigidBody::kinematicPivotChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (QDynamicRigidBody::*)(bool )>(_a, &QDynamicRigidBody::isSleepingChanged, 15))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 10:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<float> >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<float*>(_v) = _t->mass(); break;
        case 1: *reinterpret_cast<float*>(_v) = _t->density(); break;
        case 2: *reinterpret_cast<enum AxisLock*>(_v) = _t->linearAxisLock(); break;
        case 3: *reinterpret_cast<enum AxisLock*>(_v) = _t->angularAxisLock(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->isKinematic(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->gravityEnabled(); break;
        case 6: *reinterpret_cast<enum MassMode*>(_v) = _t->massMode(); break;
        case 7: *reinterpret_cast<QVector3D*>(_v) = _t->inertiaTensor(); break;
        case 8: *reinterpret_cast<QVector3D*>(_v) = _t->centerOfMassPosition(); break;
        case 9: *reinterpret_cast<QQuaternion*>(_v) = _t->centerOfMassRotation(); break;
        case 10: *reinterpret_cast<QList<float>*>(_v) = _t->readInertiaMatrix(); break;
        case 11: *reinterpret_cast<QVector3D*>(_v) = _t->kinematicPosition(); break;
        case 12: *reinterpret_cast<QVector3D*>(_v) = _t->kinematicEulerRotation(); break;
        case 13: *reinterpret_cast<QQuaternion*>(_v) = _t->kinematicRotation(); break;
        case 14: *reinterpret_cast<QVector3D*>(_v) = _t->kinematicPivot(); break;
        case 15: *reinterpret_cast<bool*>(_v) = _t->isSleeping(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setMass(*reinterpret_cast<float*>(_v)); break;
        case 1: _t->setDensity(*reinterpret_cast<float*>(_v)); break;
        case 2: _t->setLinearAxisLock(*reinterpret_cast<enum AxisLock*>(_v)); break;
        case 3: _t->setAngularAxisLock(*reinterpret_cast<enum AxisLock*>(_v)); break;
        case 4: _t->setIsKinematic(*reinterpret_cast<bool*>(_v)); break;
        case 5: _t->setGravityEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 6: _t->setMassMode(*reinterpret_cast<enum MassMode*>(_v)); break;
        case 7: _t->setInertiaTensor(*reinterpret_cast<QVector3D*>(_v)); break;
        case 8: _t->setCenterOfMassPosition(*reinterpret_cast<QVector3D*>(_v)); break;
        case 9: _t->setCenterOfMassRotation(*reinterpret_cast<QQuaternion*>(_v)); break;
        case 10: _t->setInertiaMatrix(*reinterpret_cast<QList<float>*>(_v)); break;
        case 11: _t->setKinematicPosition(*reinterpret_cast<QVector3D*>(_v)); break;
        case 12: _t->setKinematicEulerRotation(*reinterpret_cast<QVector3D*>(_v)); break;
        case 13: _t->setKinematicRotation(*reinterpret_cast<QQuaternion*>(_v)); break;
        case 14: _t->setKinematicPivot(*reinterpret_cast<QVector3D*>(_v)); break;
        case 15: _t->setIsSleeping(*reinterpret_cast<bool*>(_v)); break;
        default: break;
        }
    }
}

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

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

int QDynamicRigidBody::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAbstractPhysicsBody::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 25)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 25;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 25)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 25;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 16;
    }
    return _id;
}

// SIGNAL 0
void QDynamicRigidBody::massChanged(float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void QDynamicRigidBody::densityChanged(float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void QDynamicRigidBody::isKinematicChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

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

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

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

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

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

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

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

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

// SIGNAL 11
void QDynamicRigidBody::kinematicPositionChanged(const QVector3D & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void QDynamicRigidBody::kinematicRotationChanged(const QQuaternion & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void QDynamicRigidBody::kinematicEulerRotationChanged(const QVector3D & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void QDynamicRigidBody::kinematicPivotChanged(const QVector3D & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void QDynamicRigidBody::isSleepingChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}
QT_WARNING_POP
