/****************************************************************************
** Meta object code from reading C++ file 'qt3dquick3drenderforeign_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/quick3drender/qt3dquick3drenderforeign_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 'qt3dquick3drenderforeign_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_ZN22QRenderSettingsForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QRenderSettingsForeign::qt_create_metaobjectdata<qt_meta_tag_ZN22QRenderSettingsForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QRenderSettingsForeign",
        "QML.Element",
        "RenderSettings",
        "QML.Foreign",
        "Qt3DRender::QRenderSettings",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QRenderSettingsForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QRenderSettingsForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QRenderSettingsForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QRenderSettingsForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22QRenderSettingsForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN23QPickingSettingsForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QPickingSettingsForeign::qt_create_metaobjectdata<qt_meta_tag_ZN23QPickingSettingsForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QPickingSettingsForeign",
        "QML.Element",
        "PickingSettings",
        "QML.Foreign",
        "Qt3DRender::QPickingSettings",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QPickingSettingsForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QPickingSettingsForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QPickingSettingsForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QPickingSettingsForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23QPickingSettingsForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN26QRenderCapabilitiesForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QRenderCapabilitiesForeign::qt_create_metaobjectdata<qt_meta_tag_ZN26QRenderCapabilitiesForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QRenderCapabilitiesForeign",
        "QML.Element",
        "RenderCapabilities",
        "QML.Foreign",
        "Qt3DRender::QRenderCapabilities",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "Only available as a property of RenderSettings",
        "QML.AddedInVersion",
        "527"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
            {    9,   10 },
    });
    return QtMocHelpers::metaObjectData<QRenderCapabilitiesForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QRenderCapabilitiesForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26QRenderCapabilitiesForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26QRenderCapabilitiesForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26QRenderCapabilitiesForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN19QSceneLoaderForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QSceneLoaderForeign::qt_create_metaobjectdata<qt_meta_tag_ZN19QSceneLoaderForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSceneLoaderForeign",
        "QML.Element",
        "SceneLoader",
        "QML.Foreign",
        "Qt3DRender::QSceneLoader",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DScene",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QSceneLoaderForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QSceneLoaderForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QSceneLoaderForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QSceneLoaderForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19QSceneLoaderForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN14QEffectForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QEffectForeign::qt_create_metaobjectdata<qt_meta_tag_ZN14QEffectForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QEffectForeign",
        "QML.Element",
        "Effect",
        "QML.Foreign",
        "Qt3DRender::QEffect",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DEffect",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QEffectForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QEffectForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QEffectForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QEffectForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14QEffectForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QTechniqueForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QTechniqueForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QTechniqueForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QTechniqueForeign",
        "QML.Element",
        "Technique",
        "QML.Foreign",
        "Qt3DRender::QTechnique",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DTechnique",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QTechniqueForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QTechniqueForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QTechniqueForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QTechniqueForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QTechniqueForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QFilterKeyForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QFilterKeyForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QFilterKeyForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QFilterKeyForeign",
        "QML.Element",
        "FilterKey",
        "QML.Foreign",
        "Qt3DRender::QFilterKey",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QFilterKeyForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QFilterKeyForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QFilterKeyForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QFilterKeyForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QFilterKeyForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN25QGraphicsApiFilterForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QGraphicsApiFilterForeign::qt_create_metaobjectdata<qt_meta_tag_ZN25QGraphicsApiFilterForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QGraphicsApiFilterForeign",
        "QML.Element",
        "GraphicsApiFilter",
        "QML.Foreign",
        "Qt3DRender::QGraphicsApiFilter",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QGraphicsApiFilterForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QGraphicsApiFilterForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25QGraphicsApiFilterForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25QGraphicsApiFilterForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN25QGraphicsApiFilterForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QParameterForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QParameterForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QParameterForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QParameterForeign",
        "QML.Element",
        "QParameter",
        "QML.Foreign",
        "Qt3DRender::QParameter",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "Quick3D should instantiate Quick3DParameter only",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
            {    9,   10 },
    });
    return QtMocHelpers::metaObjectData<QParameterForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QParameterForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QParameterForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QParameterForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QParameterForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN16QMaterialForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QMaterialForeign::qt_create_metaobjectdata<qt_meta_tag_ZN16QMaterialForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QMaterialForeign",
        "QML.Element",
        "Material",
        "QML.Foreign",
        "Qt3DRender::QMaterial",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DMaterial",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QMaterialForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QMaterialForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QMaterialForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QMaterialForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16QMaterialForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN18QRenderPassForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QRenderPassForeign::qt_create_metaobjectdata<qt_meta_tag_ZN18QRenderPassForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QRenderPassForeign",
        "QML.Element",
        "RenderPass",
        "QML.Foreign",
        "Qt3DRender::QRenderPass",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DRenderPass",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QRenderPassForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QRenderPassForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QRenderPassForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QRenderPassForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18QRenderPassForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21QShaderProgramForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QShaderProgramForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21QShaderProgramForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QShaderProgramForeign",
        "QML.Element",
        "ShaderProgram",
        "QML.Foreign",
        "Qt3DRender::QShaderProgram",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QShaderProgramForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QShaderProgramForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QShaderProgramForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QShaderProgramForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QShaderProgramForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN28QShaderProgramBuilderForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QShaderProgramBuilderForeign::qt_create_metaobjectdata<qt_meta_tag_ZN28QShaderProgramBuilderForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QShaderProgramBuilderForeign",
        "QML.Element",
        "ShaderProgramBuilder",
        "QML.Foreign",
        "Qt3DRender::QShaderProgramBuilder",
        "QML.AddedInVersion",
        "522"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QShaderProgramBuilderForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QShaderProgramBuilderForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QShaderProgramBuilderForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QShaderProgramBuilderForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN28QShaderProgramBuilderForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN18QShaderDataForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QShaderDataForeign::qt_create_metaobjectdata<qt_meta_tag_ZN18QShaderDataForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QShaderDataForeign",
        "QML.Element",
        "QShaderData",
        "QML.Foreign",
        "Qt3DRender::QShaderData",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "Quick3D should instantiate Quick3DShaderData only",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
            {    9,   10 },
    });
    return QtMocHelpers::metaObjectData<QShaderDataForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QShaderDataForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QShaderDataForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QShaderDataForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18QShaderDataForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN14QCameraForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QCameraForeign::qt_create_metaobjectdata<qt_meta_tag_ZN14QCameraForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCameraForeign",
        "QML.Element",
        "Camera",
        "QML.Foreign",
        "Qt3DRender::QCamera",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QCameraForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QCameraForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCameraForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCameraForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14QCameraForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN18QCameraLensForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QCameraLensForeign::qt_create_metaobjectdata<qt_meta_tag_ZN18QCameraLensForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCameraLensForeign",
        "QML.Element",
        "CameraLens",
        "QML.Foreign",
        "Qt3DRender::QCameraLens",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QCameraLensForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QCameraLensForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QCameraLensForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QCameraLensForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18QCameraLensForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN23QTextureWrapModeForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QTextureWrapModeForeign::qt_create_metaobjectdata<qt_meta_tag_ZN23QTextureWrapModeForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QTextureWrapModeForeign",
        "QML.Element",
        "WrapMode",
        "QML.Foreign",
        "Qt3DRender::QTextureWrapMode",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QTextureWrapModeForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QTextureWrapModeForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QTextureWrapModeForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QTextureWrapModeForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23QTextureWrapModeForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN23QAbstractTextureForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QAbstractTextureForeign::qt_create_metaobjectdata<qt_meta_tag_ZN23QAbstractTextureForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QAbstractTextureForeign",
        "QML.Element",
        "Texture",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "Texture should be created from one of the subclasses",
        "QML.Foreign",
        "Qt3DRender::QAbstractTexture",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
            {    9,   10 },
    });
    return QtMocHelpers::metaObjectData<QAbstractTextureForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QAbstractTextureForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QAbstractTextureForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QAbstractTextureForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23QAbstractTextureForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QTexture1DForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QTexture1DForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QTexture1DForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QTexture1DForeign",
        "QML.Element",
        "Texture1D",
        "QML.Foreign",
        "Qt3DRender::QTexture1D",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DTextureExtension",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QTexture1DForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QTexture1DForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QTexture1DForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QTexture1DForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QTexture1DForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN22QTexture1DArrayForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QTexture1DArrayForeign::qt_create_metaobjectdata<qt_meta_tag_ZN22QTexture1DArrayForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QTexture1DArrayForeign",
        "QML.Element",
        "Texture1DArray",
        "QML.Foreign",
        "Qt3DRender::QTexture1DArray",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DTextureExtension",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QTexture1DArrayForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QTexture1DArrayForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QTexture1DArrayForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QTexture1DArrayForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22QTexture1DArrayForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QTexture2DForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QTexture2DForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QTexture2DForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QTexture2DForeign",
        "QML.Element",
        "Texture2D",
        "QML.Foreign",
        "Qt3DRender::QTexture2D",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DTextureExtension",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QTexture2DForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QTexture2DForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QTexture2DForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QTexture2DForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QTexture2DForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN22QTexture2DArrayForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QTexture2DArrayForeign::qt_create_metaobjectdata<qt_meta_tag_ZN22QTexture2DArrayForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QTexture2DArrayForeign",
        "QML.Element",
        "Texture2DArray",
        "QML.Foreign",
        "Qt3DRender::QTexture2DArray",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DTextureExtension",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QTexture2DArrayForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QTexture2DArrayForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QTexture2DArrayForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QTexture2DArrayForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22QTexture2DArrayForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QTexture3DForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QTexture3DForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QTexture3DForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QTexture3DForeign",
        "QML.Element",
        "Texture3D",
        "QML.Foreign",
        "Qt3DRender::QTexture3D",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DTextureExtension",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QTexture3DForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QTexture3DForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QTexture3DForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QTexture3DForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QTexture3DForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN22QTextureCubeMapForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QTextureCubeMapForeign::qt_create_metaobjectdata<qt_meta_tag_ZN22QTextureCubeMapForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QTextureCubeMapForeign",
        "QML.Element",
        "TextureCubeMap",
        "QML.Foreign",
        "Qt3DRender::QTextureCubeMap",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DTextureExtension",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QTextureCubeMapForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QTextureCubeMapForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QTextureCubeMapForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QTextureCubeMapForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22QTextureCubeMapForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN27QTextureCubeMapArrayForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QTextureCubeMapArrayForeign::qt_create_metaobjectdata<qt_meta_tag_ZN27QTextureCubeMapArrayForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QTextureCubeMapArrayForeign",
        "QML.Element",
        "TextureCubeMapArray",
        "QML.Foreign",
        "Qt3DRender::QTextureCubeMapArray",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DTextureExtension",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QTextureCubeMapArrayForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QTextureCubeMapArrayForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27QTextureCubeMapArrayForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27QTextureCubeMapArrayForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN27QTextureCubeMapArrayForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN28QTexture2DMultisampleForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QTexture2DMultisampleForeign::qt_create_metaobjectdata<qt_meta_tag_ZN28QTexture2DMultisampleForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QTexture2DMultisampleForeign",
        "QML.Element",
        "Texture2DMultisample",
        "QML.Foreign",
        "Qt3DRender::QTexture2DMultisample",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DTextureExtension",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QTexture2DMultisampleForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QTexture2DMultisampleForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QTexture2DMultisampleForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QTexture2DMultisampleForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN28QTexture2DMultisampleForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN33QTexture2DMultisampleArrayForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QTexture2DMultisampleArrayForeign::qt_create_metaobjectdata<qt_meta_tag_ZN33QTexture2DMultisampleArrayForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QTexture2DMultisampleArrayForeign",
        "QML.Element",
        "Texture2DMultisampleArray",
        "QML.Foreign",
        "Qt3DRender::QTexture2DMultisampleArray",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DTextureExtension",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QTexture2DMultisampleArrayForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QTexture2DMultisampleArrayForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN33QTexture2DMultisampleArrayForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN33QTexture2DMultisampleArrayForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN33QTexture2DMultisampleArrayForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN24QTextureRectangleForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QTextureRectangleForeign::qt_create_metaobjectdata<qt_meta_tag_ZN24QTextureRectangleForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QTextureRectangleForeign",
        "QML.Element",
        "TextureRectangle",
        "QML.Foreign",
        "Qt3DRender::QTextureRectangle",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DTextureExtension",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QTextureRectangleForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QTextureRectangleForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QTextureRectangleForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QTextureRectangleForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24QTextureRectangleForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21QTextureBufferForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QTextureBufferForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21QTextureBufferForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QTextureBufferForeign",
        "QML.Element",
        "TextureBuffer",
        "QML.Foreign",
        "Qt3DRender::QTextureBuffer",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DTextureExtension",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QTextureBufferForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QTextureBufferForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QTextureBufferForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QTextureBufferForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QTextureBufferForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21QTextureLoaderForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QTextureLoaderForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21QTextureLoaderForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QTextureLoaderForeign",
        "QML.Element",
        "TextureLoader",
        "QML.Foreign",
        "Qt3DRender::QTextureLoader",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DTextureExtension",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QTextureLoaderForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QTextureLoaderForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QTextureLoaderForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QTextureLoaderForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QTextureLoaderForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN28QAbstractTextureImageForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QAbstractTextureImageForeign::qt_create_metaobjectdata<qt_meta_tag_ZN28QAbstractTextureImageForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QAbstractTextureImageForeign",
        "QML.Element",
        "QAbstractTextureImage",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "QAbstractTextureImage is abstract",
        "QML.Foreign",
        "Qt3DRender::QAbstractTextureImage",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
            {    9,   10 },
    });
    return QtMocHelpers::metaObjectData<QAbstractTextureImageForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QAbstractTextureImageForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QAbstractTextureImageForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QAbstractTextureImageForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN28QAbstractTextureImageForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN20QTextureImageForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QTextureImageForeign::qt_create_metaobjectdata<qt_meta_tag_ZN20QTextureImageForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QTextureImageForeign",
        "QML.Element",
        "TextureImage",
        "QML.Foreign",
        "Qt3DRender::QTextureImage",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QTextureImageForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QTextureImageForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QTextureImageForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QTextureImageForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20QTextureImageForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN23QSharedGLTextureForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QSharedGLTextureForeign::qt_create_metaobjectdata<qt_meta_tag_ZN23QSharedGLTextureForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSharedGLTextureForeign",
        "QML.Element",
        "SharedGLTexture",
        "QML.Foreign",
        "Qt3DRender::QSharedGLTexture",
        "QML.AddedInVersion",
        "525"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QSharedGLTextureForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QSharedGLTextureForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QSharedGLTextureForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QSharedGLTextureForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23QSharedGLTextureForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN19QShaderImageForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QShaderImageForeign::qt_create_metaobjectdata<qt_meta_tag_ZN19QShaderImageForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QShaderImageForeign",
        "QML.Element",
        "ShaderImage",
        "QML.Foreign",
        "Qt3DRender::QShaderImage",
        "QML.AddedInVersion",
        "526"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QShaderImageForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QShaderImageForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QShaderImageForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QShaderImageForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19QShaderImageForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN24QGeometryRendererForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QGeometryRendererForeign::qt_create_metaobjectdata<qt_meta_tag_ZN24QGeometryRendererForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QGeometryRendererForeign",
        "QML.Element",
        "GeometryRenderer",
        "QML.Foreign",
        "Qt3DRender::QGeometryRenderer",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QGeometryRendererForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QGeometryRendererForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QGeometryRendererForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QGeometryRendererForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24QGeometryRendererForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21QLevelOfDetailForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QLevelOfDetailForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21QLevelOfDetailForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QLevelOfDetailForeign",
        "QML.Element",
        "LevelOfDetail",
        "QML.Foreign",
        "Qt3DRender::QLevelOfDetail",
        "QML.AddedInVersion",
        "521"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QLevelOfDetailForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QLevelOfDetailForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QLevelOfDetailForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QLevelOfDetailForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QLevelOfDetailForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN27QLevelOfDetailSwitchForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QLevelOfDetailSwitchForeign::qt_create_metaobjectdata<qt_meta_tag_ZN27QLevelOfDetailSwitchForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QLevelOfDetailSwitchForeign",
        "QML.Element",
        "LevelOfDetailSwitch",
        "QML.Foreign",
        "Qt3DRender::QLevelOfDetailSwitch",
        "QML.AddedInVersion",
        "521"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QLevelOfDetailSwitchForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QLevelOfDetailSwitchForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27QLevelOfDetailSwitchForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27QLevelOfDetailSwitchForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN27QLevelOfDetailSwitchForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN35QLevelOfDetailBoundingSphereForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QLevelOfDetailBoundingSphereForeign::qt_create_metaobjectdata<qt_meta_tag_ZN35QLevelOfDetailBoundingSphereForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QLevelOfDetailBoundingSphereForeign",
        "QML.Element",
        "levelOfDetailBoundingSphere",
        "QML.Foreign",
        "Qt3DRender::QLevelOfDetailBoundingSphere",
        "QML.AddedInVersion",
        "1544"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QLevelOfDetailBoundingSphereForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QLevelOfDetailBoundingSphereForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN35QLevelOfDetailBoundingSphereForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN35QLevelOfDetailBoundingSphereForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN35QLevelOfDetailBoundingSphereForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN12QMeshForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QMeshForeign::qt_create_metaobjectdata<qt_meta_tag_ZN12QMeshForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QMeshForeign",
        "QML.Element",
        "Mesh",
        "QML.Foreign",
        "Qt3DRender::QMesh",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QMeshForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QMeshForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QMeshForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QMeshForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12QMeshForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN20QObjectPickerForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QObjectPickerForeign::qt_create_metaobjectdata<qt_meta_tag_ZN20QObjectPickerForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QObjectPickerForeign",
        "QML.Element",
        "ObjectPicker",
        "QML.Foreign",
        "Qt3DRender::QObjectPicker",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QObjectPickerForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QObjectPickerForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QObjectPickerForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QObjectPickerForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20QObjectPickerForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QPickEventForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QPickEventForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QPickEventForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QPickEventForeign",
        "QML.Element",
        "PickEvent",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "Events cannot be created",
        "QML.Foreign",
        "Qt3DRender::QPickEvent",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
            {    9,   10 },
    });
    return QtMocHelpers::metaObjectData<QPickEventForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QPickEventForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QPickEventForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QPickEventForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QPickEventForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN26Quick3DRayCasterHitForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto Quick3DRayCasterHitForeign::qt_create_metaobjectdata<qt_meta_tag_ZN26Quick3DRayCasterHitForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Quick3DRayCasterHitForeign",
        "QML.Element",
        "anonymous",
        "QML.Foreign",
        "Qt3DRender::QRayCasterHit",
        "QML.AddedInVersion",
        "523"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<Quick3DRayCasterHitForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Quick3DRayCasterHitForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26Quick3DRayCasterHitForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26Quick3DRayCasterHitForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26Quick3DRayCasterHitForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN27Quick3DRayCasterHitsForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto Quick3DRayCasterHitsForeign::qt_create_metaobjectdata<qt_meta_tag_ZN27Quick3DRayCasterHitsForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Quick3DRayCasterHitsForeign",
        "QML.Element",
        "anonymous",
        "QML.Foreign",
        "Qt3DRender::QAbstractRayCaster::Hits",
        "QML.Sequence",
        "Qt3DRender::QRayCasterHit",
        "QML.AddedInVersion",
        "523"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<Quick3DRayCasterHitsForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Quick3DRayCasterHitsForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27Quick3DRayCasterHitsForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27Quick3DRayCasterHitsForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN27Quick3DRayCasterHitsForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN20QPickingProxyForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QPickingProxyForeign::qt_create_metaobjectdata<qt_meta_tag_ZN20QPickingProxyForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QPickingProxyForeign",
        "QML.Element",
        "PickingProxy",
        "QML.Foreign",
        "Qt3DRender::QPickingProxy",
        "QML.AddedInVersion",
        "528"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QPickingProxyForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QPickingProxyForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QPickingProxyForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QPickingProxyForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20QPickingProxyForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN22QComputeCommandForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QComputeCommandForeign::qt_create_metaobjectdata<qt_meta_tag_ZN22QComputeCommandForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QComputeCommandForeign",
        "QML.Element",
        "ComputeCommand",
        "QML.Foreign",
        "Qt3DRender::QComputeCommand",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QComputeCommandForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QComputeCommandForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QComputeCommandForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QComputeCommandForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22QComputeCommandForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN13QLayerForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QLayerForeign::qt_create_metaobjectdata<qt_meta_tag_ZN13QLayerForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QLayerForeign",
        "QML.Element",
        "Layer",
        "QML.Foreign",
        "Qt3DRender::QLayer",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QLayerForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QLayerForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QLayerForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QLayerForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13QLayerForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN19QLayerFilterForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QLayerFilterForeign::qt_create_metaobjectdata<qt_meta_tag_ZN19QLayerFilterForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QLayerFilterForeign",
        "QML.Element",
        "LayerFilter",
        "QML.Foreign",
        "Qt3DRender::QLayerFilter",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DLayerFilter",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QLayerFilterForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QLayerFilterForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QLayerFilterForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QLayerFilterForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19QLayerFilterForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21QAbstractLightForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QAbstractLightForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21QAbstractLightForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QAbstractLightForeign",
        "QML.Element",
        "Light",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "Light is an abstract base class",
        "QML.Foreign",
        "Qt3DRender::QAbstractLight",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
            {    9,   10 },
    });
    return QtMocHelpers::metaObjectData<QAbstractLightForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QAbstractLightForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QAbstractLightForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QAbstractLightForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QAbstractLightForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN18QPointLightForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QPointLightForeign::qt_create_metaobjectdata<qt_meta_tag_ZN18QPointLightForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QPointLightForeign",
        "QML.Element",
        "PointLight",
        "QML.Foreign",
        "Qt3DRender::QPointLight",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QPointLightForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QPointLightForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QPointLightForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QPointLightForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18QPointLightForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN24QDirectionalLightForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QDirectionalLightForeign::qt_create_metaobjectdata<qt_meta_tag_ZN24QDirectionalLightForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QDirectionalLightForeign",
        "QML.Element",
        "DirectionalLight",
        "QML.Foreign",
        "Qt3DRender::QDirectionalLight",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QDirectionalLightForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QDirectionalLightForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QDirectionalLightForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QDirectionalLightForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24QDirectionalLightForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN24QEnvironmentLightForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QEnvironmentLightForeign::qt_create_metaobjectdata<qt_meta_tag_ZN24QEnvironmentLightForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QEnvironmentLightForeign",
        "QML.Element",
        "EnvironmentLight",
        "QML.Foreign",
        "Qt3DRender::QEnvironmentLight",
        "QML.AddedInVersion",
        "521"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QEnvironmentLightForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QEnvironmentLightForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QEnvironmentLightForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QEnvironmentLightForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24QEnvironmentLightForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QSpotLightForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QSpotLightForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QSpotLightForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSpotLightForeign",
        "QML.Element",
        "SpotLight",
        "QML.Foreign",
        "Qt3DRender::QSpotLight",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QSpotLightForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QSpotLightForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QSpotLightForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QSpotLightForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QSpotLightForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN22QCameraSelectorForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QCameraSelectorForeign::qt_create_metaobjectdata<qt_meta_tag_ZN22QCameraSelectorForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCameraSelectorForeign",
        "QML.Element",
        "CameraSelector",
        "QML.Foreign",
        "Qt3DRender::QCameraSelector",
        "QML.Extended",
        "Qt3DCore::Quick::Quick3DNode",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QCameraSelectorForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QCameraSelectorForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QCameraSelectorForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QCameraSelectorForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22QCameraSelectorForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN24QRenderPassFilterForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QRenderPassFilterForeign::qt_create_metaobjectdata<qt_meta_tag_ZN24QRenderPassFilterForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QRenderPassFilterForeign",
        "QML.Element",
        "RenderPassFilter",
        "QML.Foreign",
        "Qt3DRender::QRenderPassFilter",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DRenderPassFilter",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QRenderPassFilterForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QRenderPassFilterForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QRenderPassFilterForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QRenderPassFilterForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24QRenderPassFilterForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN23QTechniqueFilterForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QTechniqueFilterForeign::qt_create_metaobjectdata<qt_meta_tag_ZN23QTechniqueFilterForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QTechniqueFilterForeign",
        "QML.Element",
        "TechniqueFilter",
        "QML.Foreign",
        "Qt3DRender::QTechniqueFilter",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DTechniqueFilter",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QTechniqueFilterForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QTechniqueFilterForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QTechniqueFilterForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QTechniqueFilterForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23QTechniqueFilterForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN16QViewportForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QViewportForeign::qt_create_metaobjectdata<qt_meta_tag_ZN16QViewportForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QViewportForeign",
        "QML.Element",
        "Viewport",
        "QML.Foreign",
        "Qt3DRender::QViewport",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DViewport",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QViewportForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QViewportForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QViewportForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QViewportForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16QViewportForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN28QRenderTargetSelectorForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QRenderTargetSelectorForeign::qt_create_metaobjectdata<qt_meta_tag_ZN28QRenderTargetSelectorForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QRenderTargetSelectorForeign",
        "QML.Element",
        "RenderTargetSelector",
        "QML.Foreign",
        "Qt3DRender::QRenderTargetSelector",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QRenderTargetSelectorForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QRenderTargetSelectorForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QRenderTargetSelectorForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QRenderTargetSelectorForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN28QRenderTargetSelectorForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN20QClearBuffersForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QClearBuffersForeign::qt_create_metaobjectdata<qt_meta_tag_ZN20QClearBuffersForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QClearBuffersForeign",
        "QML.Element",
        "ClearBuffers",
        "QML.Foreign",
        "Qt3DRender::QClearBuffers",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QClearBuffersForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QClearBuffersForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QClearBuffersForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QClearBuffersForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20QClearBuffersForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN22QFrameGraphNodeForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QFrameGraphNodeForeign::qt_create_metaobjectdata<qt_meta_tag_ZN22QFrameGraphNodeForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QFrameGraphNodeForeign",
        "QML.Element",
        "FrameGraphNode",
        "QML.Foreign",
        "Qt3DRender::QFrameGraphNode",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QFrameGraphNodeForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QFrameGraphNodeForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QFrameGraphNodeForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QFrameGraphNodeForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22QFrameGraphNodeForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN22QRenderStateSetForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QRenderStateSetForeign::qt_create_metaobjectdata<qt_meta_tag_ZN22QRenderStateSetForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QRenderStateSetForeign",
        "QML.Element",
        "RenderStateSet",
        "QML.Foreign",
        "Qt3DRender::QRenderStateSet",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DStateSet",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QRenderStateSetForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QRenderStateSetForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QRenderStateSetForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QRenderStateSetForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22QRenderStateSetForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN14QNoDrawForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QNoDrawForeign::qt_create_metaobjectdata<qt_meta_tag_ZN14QNoDrawForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QNoDrawForeign",
        "QML.Element",
        "NoDraw",
        "QML.Foreign",
        "Qt3DRender::QNoDraw",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QNoDrawForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QNoDrawForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QNoDrawForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QNoDrawForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14QNoDrawForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN22QFrustumCullingForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QFrustumCullingForeign::qt_create_metaobjectdata<qt_meta_tag_ZN22QFrustumCullingForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QFrustumCullingForeign",
        "QML.Element",
        "FrustumCulling",
        "QML.Foreign",
        "Qt3DRender::QFrustumCulling",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QFrustumCullingForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QFrustumCullingForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QFrustumCullingForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QFrustumCullingForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22QFrustumCullingForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN23QDispatchComputeForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QDispatchComputeForeign::qt_create_metaobjectdata<qt_meta_tag_ZN23QDispatchComputeForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QDispatchComputeForeign",
        "QML.Element",
        "DispatchCompute",
        "QML.Foreign",
        "Qt3DRender::QDispatchCompute",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QDispatchComputeForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QDispatchComputeForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QDispatchComputeForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QDispatchComputeForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23QDispatchComputeForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21QRenderCaptureForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QRenderCaptureForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21QRenderCaptureForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QRenderCaptureForeign",
        "QML.Element",
        "RenderCapture",
        "QML.Foreign",
        "Qt3DRender::QRenderCapture",
        "QML.AddedInVersion",
        "513"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QRenderCaptureForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QRenderCaptureForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QRenderCaptureForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QRenderCaptureForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QRenderCaptureForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN26QRenderCaptureReplyForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QRenderCaptureReplyForeign::qt_create_metaobjectdata<qt_meta_tag_ZN26QRenderCaptureReplyForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QRenderCaptureReplyForeign",
        "QML.Element",
        "RenderCaptureReply",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "RenderCaptureReply is only instantiated by RenderCapture",
        "QML.Foreign",
        "Qt3DRender::QRenderCaptureReply",
        "QML.AddedInVersion",
        "513"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
            {    9,   10 },
    });
    return QtMocHelpers::metaObjectData<QRenderCaptureReplyForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QRenderCaptureReplyForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26QRenderCaptureReplyForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26QRenderCaptureReplyForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26QRenderCaptureReplyForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21QBufferCaptureForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QBufferCaptureForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21QBufferCaptureForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QBufferCaptureForeign",
        "QML.Element",
        "BufferCapture",
        "QML.Foreign",
        "Qt3DRender::QBufferCapture",
        "QML.AddedInVersion",
        "521"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QBufferCaptureForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QBufferCaptureForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QBufferCaptureForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QBufferCaptureForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QBufferCaptureForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21QMemoryBarrierForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QMemoryBarrierForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21QMemoryBarrierForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QMemoryBarrierForeign",
        "QML.Element",
        "MemoryBarrier",
        "QML.Foreign",
        "Qt3DRender::QMemoryBarrier",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DMemoryBarrier",
        "QML.AddedInVersion",
        "521"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QMemoryBarrierForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QMemoryBarrierForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QMemoryBarrierForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QMemoryBarrierForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QMemoryBarrierForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN23QProximityFilterForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QProximityFilterForeign::qt_create_metaobjectdata<qt_meta_tag_ZN23QProximityFilterForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QProximityFilterForeign",
        "QML.Element",
        "ProximityFilter",
        "QML.Foreign",
        "Qt3DRender::QProximityFilter",
        "QML.AddedInVersion",
        "522"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QProximityFilterForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QProximityFilterForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QProximityFilterForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QProximityFilterForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23QProximityFilterForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN23QBlitFramebufferForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QBlitFramebufferForeign::qt_create_metaobjectdata<qt_meta_tag_ZN23QBlitFramebufferForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QBlitFramebufferForeign",
        "QML.Element",
        "BlitFramebuffer",
        "QML.Foreign",
        "Qt3DRender::QBlitFramebuffer",
        "QML.AddedInVersion",
        "522"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QBlitFramebufferForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QBlitFramebufferForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QBlitFramebufferForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QBlitFramebufferForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23QBlitFramebufferForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN16QSetFenceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QSetFenceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN16QSetFenceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSetFenceForeign",
        "QML.Element",
        "SetFence",
        "QML.Foreign",
        "Qt3DRender::QSetFence",
        "QML.AddedInVersion",
        "525"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QSetFenceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QSetFenceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QSetFenceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QSetFenceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16QSetFenceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QWaitFenceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QWaitFenceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QWaitFenceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QWaitFenceForeign",
        "QML.Element",
        "WaitFence",
        "QML.Foreign",
        "Qt3DRender::QWaitFence",
        "QML.AddedInVersion",
        "525"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QWaitFenceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QWaitFenceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QWaitFenceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QWaitFenceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QWaitFenceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QNoPickingForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QNoPickingForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QNoPickingForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QNoPickingForeign",
        "QML.Element",
        "NoPicking",
        "QML.Foreign",
        "Qt3DRender::QNoPicking",
        "QML.AddedInVersion",
        "526"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QNoPickingForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QNoPickingForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QNoPickingForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QNoPickingForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QNoPickingForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN22QSubtreeEnablerForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QSubtreeEnablerForeign::qt_create_metaobjectdata<qt_meta_tag_ZN22QSubtreeEnablerForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSubtreeEnablerForeign",
        "QML.Element",
        "SubtreeEnabler",
        "QML.Foreign",
        "Qt3DRender::QSubtreeEnabler",
        "QML.AddedInVersion",
        "526"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QSubtreeEnablerForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QSubtreeEnablerForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QSubtreeEnablerForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QSubtreeEnablerForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22QSubtreeEnablerForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN20QDebugOverlayForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QDebugOverlayForeign::qt_create_metaobjectdata<qt_meta_tag_ZN20QDebugOverlayForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QDebugOverlayForeign",
        "QML.Element",
        "DebugOverlay",
        "QML.Foreign",
        "Qt3DRender::QDebugOverlay",
        "QML.AddedInVersion",
        "528"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QDebugOverlayForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QDebugOverlayForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QDebugOverlayForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QDebugOverlayForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20QDebugOverlayForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN26QRenderTargetOutputForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QRenderTargetOutputForeign::qt_create_metaobjectdata<qt_meta_tag_ZN26QRenderTargetOutputForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QRenderTargetOutputForeign",
        "QML.Element",
        "RenderTargetOutput",
        "QML.Foreign",
        "Qt3DRender::QRenderTargetOutput",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QRenderTargetOutputForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QRenderTargetOutputForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26QRenderTargetOutputForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26QRenderTargetOutputForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26QRenderTargetOutputForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN20QRenderTargetForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QRenderTargetForeign::qt_create_metaobjectdata<qt_meta_tag_ZN20QRenderTargetForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QRenderTargetForeign",
        "QML.Element",
        "RenderTarget",
        "QML.Foreign",
        "Qt3DRender::QRenderTarget",
        "QML.Extended",
        "Qt3DRender::Render::Quick::Quick3DRenderTargetOutput",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QRenderTargetForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QRenderTargetForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QRenderTargetForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QRenderTargetForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20QRenderTargetForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN29QRenderSurfaceSelectorForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QRenderSurfaceSelectorForeign::qt_create_metaobjectdata<qt_meta_tag_ZN29QRenderSurfaceSelectorForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QRenderSurfaceSelectorForeign",
        "QML.Element",
        "RenderSurfaceSelector",
        "QML.Foreign",
        "Qt3DRender::QRenderSurfaceSelector",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QRenderSurfaceSelectorForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QRenderSurfaceSelectorForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29QRenderSurfaceSelectorForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29QRenderSurfaceSelectorForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN29QRenderSurfaceSelectorForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN18QSortPolicyForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QSortPolicyForeign::qt_create_metaobjectdata<qt_meta_tag_ZN18QSortPolicyForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSortPolicyForeign",
        "QML.Element",
        "SortPolicy",
        "QML.Foreign",
        "Qt3DRender::QSortPolicy",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QSortPolicyForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QSortPolicyForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QSortPolicyForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QSortPolicyForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18QSortPolicyForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN19QRenderStateForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QRenderStateForeign::qt_create_metaobjectdata<qt_meta_tag_ZN19QRenderStateForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QRenderStateForeign",
        "QML.Element",
        "RenderState",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "QRenderState is a base class",
        "QML.Foreign",
        "Qt3DRender::QRenderState",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
            {    9,   10 },
    });
    return QtMocHelpers::metaObjectData<QRenderStateForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QRenderStateForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QRenderStateForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QRenderStateForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19QRenderStateForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN30QBlendEquationArgumentsForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QBlendEquationArgumentsForeign::qt_create_metaobjectdata<qt_meta_tag_ZN30QBlendEquationArgumentsForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QBlendEquationArgumentsForeign",
        "QML.Element",
        "BlendEquationArguments",
        "QML.Foreign",
        "Qt3DRender::QBlendEquationArguments",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QBlendEquationArgumentsForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QBlendEquationArgumentsForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN30QBlendEquationArgumentsForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN30QBlendEquationArgumentsForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN30QBlendEquationArgumentsForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21QBlendEquationForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QBlendEquationForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21QBlendEquationForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QBlendEquationForeign",
        "QML.Element",
        "BlendEquation",
        "QML.Foreign",
        "Qt3DRender::QBlendEquation",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QBlendEquationForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QBlendEquationForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QBlendEquationForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QBlendEquationForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QBlendEquationForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QAlphaTestForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QAlphaTestForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QAlphaTestForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QAlphaTestForeign",
        "QML.Element",
        "AlphaTest",
        "QML.Foreign",
        "Qt3DRender::QAlphaTest",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QAlphaTestForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QAlphaTestForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QAlphaTestForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QAlphaTestForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QAlphaTestForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN18QDepthRangeForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QDepthRangeForeign::qt_create_metaobjectdata<qt_meta_tag_ZN18QDepthRangeForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QDepthRangeForeign",
        "QML.Element",
        "DepthRange",
        "QML.Foreign",
        "Qt3DRender::QDepthRange",
        "QML.AddedInVersion",
        "526"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QDepthRangeForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QDepthRangeForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QDepthRangeForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QDepthRangeForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18QDepthRangeForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QDepthTestForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QDepthTestForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QDepthTestForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QDepthTestForeign",
        "QML.Element",
        "DepthTest",
        "QML.Foreign",
        "Qt3DRender::QDepthTest",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QDepthTestForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QDepthTestForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QDepthTestForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QDepthTestForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QDepthTestForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN31QMultiSampleAntiAliasingForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QMultiSampleAntiAliasingForeign::qt_create_metaobjectdata<qt_meta_tag_ZN31QMultiSampleAntiAliasingForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QMultiSampleAntiAliasingForeign",
        "QML.Element",
        "MultiSampleAntiAliasing",
        "QML.Foreign",
        "Qt3DRender::QMultiSampleAntiAliasing",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QMultiSampleAntiAliasingForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QMultiSampleAntiAliasingForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN31QMultiSampleAntiAliasingForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN31QMultiSampleAntiAliasingForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN31QMultiSampleAntiAliasingForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN19QNoDepthMaskForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QNoDepthMaskForeign::qt_create_metaobjectdata<qt_meta_tag_ZN19QNoDepthMaskForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QNoDepthMaskForeign",
        "QML.Element",
        "NoDepthMask",
        "QML.Foreign",
        "Qt3DRender::QNoDepthMask",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QNoDepthMaskForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QNoDepthMaskForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QNoDepthMaskForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QNoDepthMaskForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19QNoDepthMaskForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN16QCullFaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QCullFaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN16QCullFaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCullFaceForeign",
        "QML.Element",
        "CullFace",
        "QML.Foreign",
        "Qt3DRender::QCullFace",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QCullFaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QCullFaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QCullFaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QCullFaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16QCullFaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QFrontFaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QFrontFaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QFrontFaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QFrontFaceForeign",
        "QML.Element",
        "FrontFace",
        "QML.Foreign",
        "Qt3DRender::QFrontFace",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QFrontFaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QFrontFaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QFrontFaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QFrontFaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QFrontFaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN28QStencilTestArgumentsForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QStencilTestArgumentsForeign::qt_create_metaobjectdata<qt_meta_tag_ZN28QStencilTestArgumentsForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QStencilTestArgumentsForeign",
        "QML.Element",
        "StencilTestArguments",
        "QML.Foreign",
        "Qt3DRender::QStencilTestArguments",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "QStencilTestArguments cannot be instantiated on its own",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
            {    9,   10 },
    });
    return QtMocHelpers::metaObjectData<QStencilTestArgumentsForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QStencilTestArgumentsForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QStencilTestArgumentsForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QStencilTestArgumentsForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN28QStencilTestArgumentsForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN19QStencilTestForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QStencilTestForeign::qt_create_metaobjectdata<qt_meta_tag_ZN19QStencilTestForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QStencilTestForeign",
        "QML.Element",
        "StencilTest",
        "QML.Foreign",
        "Qt3DRender::QStencilTest",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QStencilTestForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QStencilTestForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QStencilTestForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QStencilTestForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19QStencilTestForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN19QScissorTestForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QScissorTestForeign::qt_create_metaobjectdata<qt_meta_tag_ZN19QScissorTestForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QScissorTestForeign",
        "QML.Element",
        "ScissorTest",
        "QML.Foreign",
        "Qt3DRender::QScissorTest",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QScissorTestForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QScissorTestForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QScissorTestForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QScissorTestForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19QScissorTestForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QDitheringForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QDitheringForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QDitheringForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QDitheringForeign",
        "QML.Element",
        "Dithering",
        "QML.Foreign",
        "Qt3DRender::QDithering",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QDitheringForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QDitheringForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QDitheringForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QDitheringForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QDitheringForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21QAlphaCoverageForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QAlphaCoverageForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21QAlphaCoverageForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QAlphaCoverageForeign",
        "QML.Element",
        "AlphaCoverage",
        "QML.Foreign",
        "Qt3DRender::QAlphaCoverage",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QAlphaCoverageForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QAlphaCoverageForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QAlphaCoverageForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QAlphaCoverageForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QAlphaCoverageForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QPointSizeForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QPointSizeForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QPointSizeForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QPointSizeForeign",
        "QML.Element",
        "PointSize",
        "QML.Foreign",
        "Qt3DRender::QPointSize",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QPointSizeForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QPointSizeForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QPointSizeForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QPointSizeForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QPointSizeForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN21QPolygonOffsetForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QPolygonOffsetForeign::qt_create_metaobjectdata<qt_meta_tag_ZN21QPolygonOffsetForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QPolygonOffsetForeign",
        "QML.Element",
        "PolygonOffset",
        "QML.Foreign",
        "Qt3DRender::QPolygonOffset",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QPolygonOffsetForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QPolygonOffsetForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QPolygonOffsetForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QPolygonOffsetForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QPolygonOffsetForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QColorMaskForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QColorMaskForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QColorMaskForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QColorMaskForeign",
        "QML.Element",
        "ColorMask",
        "QML.Foreign",
        "Qt3DRender::QColorMask",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QColorMaskForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QColorMaskForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QColorMaskForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QColorMaskForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QColorMaskForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QClipPlaneForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QClipPlaneForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QClipPlaneForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QClipPlaneForeign",
        "QML.Element",
        "ClipPlane",
        "QML.Foreign",
        "Qt3DRender::QClipPlane",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QClipPlaneForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QClipPlaneForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QClipPlaneForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QClipPlaneForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QClipPlaneForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN33QStencilOperationArgumentsForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QStencilOperationArgumentsForeign::qt_create_metaobjectdata<qt_meta_tag_ZN33QStencilOperationArgumentsForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QStencilOperationArgumentsForeign",
        "QML.Element",
        "StencilOperationArguments",
        "QML.Foreign",
        "Qt3DRender::QStencilOperationArguments",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "StencilOperationArguments cannot be instanciated on its own",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
            {    9,   10 },
    });
    return QtMocHelpers::metaObjectData<QStencilOperationArgumentsForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QStencilOperationArgumentsForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN33QStencilOperationArgumentsForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN33QStencilOperationArgumentsForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN33QStencilOperationArgumentsForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN23QSeamlessCubemapForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QSeamlessCubemapForeign::qt_create_metaobjectdata<qt_meta_tag_ZN23QSeamlessCubemapForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSeamlessCubemapForeign",
        "QML.Element",
        "SeamlessCubemap",
        "QML.Foreign",
        "Qt3DRender::QSeamlessCubemap",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QSeamlessCubemapForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QSeamlessCubemapForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QSeamlessCubemapForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QSeamlessCubemapForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23QSeamlessCubemapForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN24QStencilOperationForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QStencilOperationForeign::qt_create_metaobjectdata<qt_meta_tag_ZN24QStencilOperationForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QStencilOperationForeign",
        "QML.Element",
        "StencilOperation",
        "QML.Foreign",
        "Qt3DRender::QStencilOperation",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QStencilOperationForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QStencilOperationForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QStencilOperationForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QStencilOperationForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24QStencilOperationForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN19QStencilMaskForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QStencilMaskForeign::qt_create_metaobjectdata<qt_meta_tag_ZN19QStencilMaskForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QStencilMaskForeign",
        "QML.Element",
        "StencilMask",
        "QML.Foreign",
        "Qt3DRender::QStencilMask",
        "QML.AddedInVersion",
        "512"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QStencilMaskForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QStencilMaskForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QStencilMaskForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QStencilMaskForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19QStencilMaskForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17QLineWidthForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QLineWidthForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17QLineWidthForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QLineWidthForeign",
        "QML.Element",
        "LineWidth",
        "QML.Foreign",
        "Qt3DRender::QLineWidth",
        "QML.AddedInVersion",
        "522"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QLineWidthForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QLineWidthForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QLineWidthForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QLineWidthForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QLineWidthForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN18QRasterModeForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto QRasterModeForeign::qt_create_metaobjectdata<qt_meta_tag_ZN18QRasterModeForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QRasterModeForeign",
        "QML.Element",
        "RasterMode",
        "QML.Foreign",
        "Qt3DRender::QRasterMode",
        "QML.AddedInVersion",
        "525"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<QRasterModeForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QRasterModeForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QRasterModeForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QRasterModeForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18QRasterModeForeignE_t>.metaTypes,
    nullptr
} };

QT_WARNING_POP
