/****************************************************************************
** Meta object code from reading C++ file 'qabstracttexture.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/render/texture/qabstracttexture.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 'qabstracttexture.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_ZN10Qt3DRender16QAbstractTextureE_t {};
} // unnamed namespace

template <> constexpr inline auto Qt3DRender::QAbstractTexture::qt_create_metaobjectdata<qt_meta_tag_ZN10Qt3DRender16QAbstractTextureE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Qt3DRender::QAbstractTexture",
        "formatChanged",
        "",
        "TextureFormat",
        "format",
        "statusChanged",
        "Status",
        "status",
        "generateMipMapsChanged",
        "generateMipMaps",
        "widthChanged",
        "width",
        "heightChanged",
        "height",
        "depthChanged",
        "depth",
        "magnificationFilterChanged",
        "Filter",
        "magnificationFilter",
        "minificationFilterChanged",
        "minificationFilter",
        "maximumAnisotropyChanged",
        "maximumAnisotropy",
        "comparisonFunctionChanged",
        "ComparisonFunction",
        "comparisonFunction",
        "comparisonModeChanged",
        "ComparisonMode",
        "comparisonMode",
        "layersChanged",
        "layers",
        "samplesChanged",
        "samples",
        "handleTypeChanged",
        "HandleType",
        "handleType",
        "handleChanged",
        "QVariant",
        "handle",
        "mipLevelsChanged",
        "mipLevels",
        "setFormat",
        "setGenerateMipMaps",
        "gen",
        "setWidth",
        "setHeight",
        "setDepth",
        "setMinificationFilter",
        "f",
        "setMagnificationFilter",
        "setMaximumAnisotropy",
        "anisotropy",
        "setComparisonFunction",
        "function",
        "setComparisonMode",
        "mode",
        "setLayers",
        "setSamples",
        "setMipLevels",
        "updateData",
        "QTextureDataUpdate",
        "update",
        "target",
        "Target",
        "wrapMode",
        "Qt3DRender::QTextureWrapMode*",
        "None",
        "Loading",
        "Ready",
        "Error",
        "TargetAutomatic",
        "Target1D",
        "Target1DArray",
        "Target2D",
        "Target2DArray",
        "Target3D",
        "TargetCubeMap",
        "TargetCubeMapArray",
        "Target2DMultisample",
        "Target2DMultisampleArray",
        "TargetRectangle",
        "TargetBuffer",
        "NoFormat",
        "Automatic",
        "R8_UNorm",
        "RG8_UNorm",
        "RGB8_UNorm",
        "RGBA8_UNorm",
        "R16_UNorm",
        "RG16_UNorm",
        "RGB16_UNorm",
        "RGBA16_UNorm",
        "R8_SNorm",
        "RG8_SNorm",
        "RGB8_SNorm",
        "RGBA8_SNorm",
        "R16_SNorm",
        "RG16_SNorm",
        "RGB16_SNorm",
        "RGBA16_SNorm",
        "R8U",
        "RG8U",
        "RGB8U",
        "RGBA8U",
        "R16U",
        "RG16U",
        "RGB16U",
        "RGBA16U",
        "R32U",
        "RG32U",
        "RGB32U",
        "RGBA32U",
        "R8I",
        "RG8I",
        "RGB8I",
        "RGBA8I",
        "R16I",
        "RG16I",
        "RGB16I",
        "RGBA16I",
        "R32I",
        "RG32I",
        "RGB32I",
        "RGBA32I",
        "R16F",
        "RG16F",
        "RGB16F",
        "RGBA16F",
        "R32F",
        "RG32F",
        "RGB32F",
        "RGBA32F",
        "RGB9E5",
        "RG11B10F",
        "RG3B2",
        "R5G6B5",
        "RGB5A1",
        "RGBA4",
        "RGB10A2",
        "RGB10A2U",
        "D16",
        "D24",
        "D24S8",
        "D32",
        "D32F",
        "D32FS8X24",
        "RGB_DXT1",
        "RGBA_DXT1",
        "RGBA_DXT3",
        "RGBA_DXT5",
        "R_ATI1N_UNorm",
        "R_ATI1N_SNorm",
        "RG_ATI2N_UNorm",
        "RG_ATI2N_SNorm",
        "RGB_BP_UNSIGNED_FLOAT",
        "RGB_BP_SIGNED_FLOAT",
        "RGB_BP_UNorm",
        "R11_EAC_UNorm",
        "R11_EAC_SNorm",
        "RG11_EAC_UNorm",
        "RG11_EAC_SNorm",
        "RGB8_ETC2",
        "SRGB8_ETC2",
        "RGB8_PunchThrough_Alpha1_ETC2",
        "SRGB8_PunchThrough_Alpha1_ETC2",
        "RGBA8_ETC2_EAC",
        "SRGB8_Alpha8_ETC2_EAC",
        "RGB8_ETC1",
        "SRGB8",
        "SRGB8_Alpha8",
        "SRGB_DXT1",
        "SRGB_Alpha_DXT1",
        "SRGB_Alpha_DXT3",
        "SRGB_Alpha_DXT5",
        "SRGB_BP_UNorm",
        "DepthFormat",
        "AlphaFormat",
        "RGBFormat",
        "RGBAFormat",
        "LuminanceFormat",
        "LuminanceAlphaFormat",
        "Nearest",
        "Linear",
        "NearestMipMapNearest",
        "NearestMipMapLinear",
        "LinearMipMapNearest",
        "LinearMipMapLinear",
        "CubeMapFace",
        "CubeMapPositiveX",
        "CubeMapNegativeX",
        "CubeMapPositiveY",
        "CubeMapNegativeY",
        "CubeMapPositiveZ",
        "CubeMapNegativeZ",
        "AllFaces",
        "CompareLessEqual",
        "CompareGreaterEqual",
        "CompareLess",
        "CompareGreater",
        "CompareEqual",
        "CommpareNotEqual",
        "CompareAlways",
        "CompareNever",
        "CompareRefToTexture",
        "CompareNone",
        "NoHandle",
        "OpenGLTextureId",
        "RHITextureId"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'formatChanged'
        QtMocHelpers::SignalData<void(enum TextureFormat)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'statusChanged'
        QtMocHelpers::SignalData<void(enum Status)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Signal 'generateMipMapsChanged'
        QtMocHelpers::SignalData<void(bool)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 9 },
        }}),
        // Signal 'widthChanged'
        QtMocHelpers::SignalData<void(int)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Signal 'heightChanged'
        QtMocHelpers::SignalData<void(int)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Signal 'depthChanged'
        QtMocHelpers::SignalData<void(int)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 15 },
        }}),
        // Signal 'magnificationFilterChanged'
        QtMocHelpers::SignalData<void(enum Filter)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 17, 18 },
        }}),
        // Signal 'minificationFilterChanged'
        QtMocHelpers::SignalData<void(enum Filter)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 17, 20 },
        }}),
        // Signal 'maximumAnisotropyChanged'
        QtMocHelpers::SignalData<void(float)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 22 },
        }}),
        // Signal 'comparisonFunctionChanged'
        QtMocHelpers::SignalData<void(enum ComparisonFunction)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 24, 25 },
        }}),
        // Signal 'comparisonModeChanged'
        QtMocHelpers::SignalData<void(enum ComparisonMode)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'layersChanged'
        QtMocHelpers::SignalData<void(int)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 30 },
        }}),
        // Signal 'samplesChanged'
        QtMocHelpers::SignalData<void(int)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 32 },
        }}),
        // Signal 'handleTypeChanged'
        QtMocHelpers::RevisionedSignalData<void(enum HandleType)>(33, 2, QMC::AccessPublic, 0xff0d, QMetaType::Void, {{
            { 0x80000000 | 34, 35 },
        }}),
        // Signal 'handleChanged'
        QtMocHelpers::RevisionedSignalData<void(QVariant)>(36, 2, QMC::AccessPublic, 0xff0d, QMetaType::Void, {{
            { 0x80000000 | 37, 38 },
        }}),
        // Signal 'mipLevelsChanged'
        QtMocHelpers::SignalData<void(int)>(39, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 40 },
        }}),
        // Slot 'setFormat'
        QtMocHelpers::SlotData<void(enum TextureFormat)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Slot 'setGenerateMipMaps'
        QtMocHelpers::SlotData<void(bool)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 43 },
        }}),
        // Slot 'setWidth'
        QtMocHelpers::SlotData<void(int)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Slot 'setHeight'
        QtMocHelpers::SlotData<void(int)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Slot 'setDepth'
        QtMocHelpers::SlotData<void(int)>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 15 },
        }}),
        // Slot 'setMinificationFilter'
        QtMocHelpers::SlotData<void(enum Filter)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 17, 48 },
        }}),
        // Slot 'setMagnificationFilter'
        QtMocHelpers::SlotData<void(enum Filter)>(49, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 17, 48 },
        }}),
        // Slot 'setMaximumAnisotropy'
        QtMocHelpers::SlotData<void(float)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 51 },
        }}),
        // Slot 'setComparisonFunction'
        QtMocHelpers::SlotData<void(enum ComparisonFunction)>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 24, 53 },
        }}),
        // Slot 'setComparisonMode'
        QtMocHelpers::SlotData<void(enum ComparisonMode)>(54, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 55 },
        }}),
        // Slot 'setLayers'
        QtMocHelpers::SlotData<void(int)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 30 },
        }}),
        // Slot 'setSamples'
        QtMocHelpers::SlotData<void(int)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 32 },
        }}),
        // Slot 'setMipLevels'
        QtMocHelpers::SlotData<void(int)>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 40 },
        }}),
        // Method 'updateData'
        QtMocHelpers::MethodData<void(const QTextureDataUpdate &)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 60, 61 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'target'
        QtMocHelpers::PropertyData<enum Target>(62, 0x80000000 | 63, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'format'
        QtMocHelpers::PropertyData<enum TextureFormat>(4, 0x80000000 | 3, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 0),
        // property 'generateMipMaps'
        QtMocHelpers::PropertyData<bool>(9, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'wrapMode'
        QtMocHelpers::PropertyData<Qt3DRender::QTextureWrapMode*>(64, 0x80000000 | 65, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'status'
        QtMocHelpers::PropertyData<enum Status>(7, 0x80000000 | 6, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 1),
        // property 'width'
        QtMocHelpers::PropertyData<int>(11, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 3),
        // property 'height'
        QtMocHelpers::PropertyData<int>(13, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 4),
        // property 'depth'
        QtMocHelpers::PropertyData<int>(15, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 5),
        // property 'mipLevels'
        QtMocHelpers::PropertyData<int>(40, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 15),
        // property 'magnificationFilter'
        QtMocHelpers::PropertyData<enum Filter>(18, 0x80000000 | 17, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 6),
        // property 'minificationFilter'
        QtMocHelpers::PropertyData<enum Filter>(20, 0x80000000 | 17, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 7),
        // property 'maximumAnisotropy'
        QtMocHelpers::PropertyData<float>(22, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 8),
        // property 'comparisonFunction'
        QtMocHelpers::PropertyData<enum ComparisonFunction>(25, 0x80000000 | 24, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 9),
        // property 'comparisonMode'
        QtMocHelpers::PropertyData<enum ComparisonMode>(28, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 10),
        // property 'layers'
        QtMocHelpers::PropertyData<int>(30, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 11),
        // property 'samples'
        QtMocHelpers::PropertyData<int>(32, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 12),
        // property 'handleType'
        QtMocHelpers::PropertyData<enum HandleType>(35, 0x80000000 | 34, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 13, 0x20d),
        // property 'handle'
        QtMocHelpers::PropertyData<QVariant>(38, 0x80000000 | 37, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 14, 0x20d),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Status'
        QtMocHelpers::EnumData<enum Status>(6, 6, QMC::EnumFlags{}).add({
            {   66, Status::None },
            {   67, Status::Loading },
            {   68, Status::Ready },
            {   69, Status::Error },
        }),
        // enum 'Target'
        QtMocHelpers::EnumData<enum Target>(63, 63, QMC::EnumFlags{}).add({
            {   70, Target::TargetAutomatic },
            {   71, Target::Target1D },
            {   72, Target::Target1DArray },
            {   73, Target::Target2D },
            {   74, Target::Target2DArray },
            {   75, Target::Target3D },
            {   76, Target::TargetCubeMap },
            {   77, Target::TargetCubeMapArray },
            {   78, Target::Target2DMultisample },
            {   79, Target::Target2DMultisampleArray },
            {   80, Target::TargetRectangle },
            {   81, Target::TargetBuffer },
        }),
        // enum 'TextureFormat'
        QtMocHelpers::EnumData<enum TextureFormat>(3, 3, QMC::EnumFlags{}).add({
            {   82, TextureFormat::NoFormat },
            {   83, TextureFormat::Automatic },
            {   84, TextureFormat::R8_UNorm },
            {   85, TextureFormat::RG8_UNorm },
            {   86, TextureFormat::RGB8_UNorm },
            {   87, TextureFormat::RGBA8_UNorm },
            {   88, TextureFormat::R16_UNorm },
            {   89, TextureFormat::RG16_UNorm },
            {   90, TextureFormat::RGB16_UNorm },
            {   91, TextureFormat::RGBA16_UNorm },
            {   92, TextureFormat::R8_SNorm },
            {   93, TextureFormat::RG8_SNorm },
            {   94, TextureFormat::RGB8_SNorm },
            {   95, TextureFormat::RGBA8_SNorm },
            {   96, TextureFormat::R16_SNorm },
            {   97, TextureFormat::RG16_SNorm },
            {   98, TextureFormat::RGB16_SNorm },
            {   99, TextureFormat::RGBA16_SNorm },
            {  100, TextureFormat::R8U },
            {  101, TextureFormat::RG8U },
            {  102, TextureFormat::RGB8U },
            {  103, TextureFormat::RGBA8U },
            {  104, TextureFormat::R16U },
            {  105, TextureFormat::RG16U },
            {  106, TextureFormat::RGB16U },
            {  107, TextureFormat::RGBA16U },
            {  108, TextureFormat::R32U },
            {  109, TextureFormat::RG32U },
            {  110, TextureFormat::RGB32U },
            {  111, TextureFormat::RGBA32U },
            {  112, TextureFormat::R8I },
            {  113, TextureFormat::RG8I },
            {  114, TextureFormat::RGB8I },
            {  115, TextureFormat::RGBA8I },
            {  116, TextureFormat::R16I },
            {  117, TextureFormat::RG16I },
            {  118, TextureFormat::RGB16I },
            {  119, TextureFormat::RGBA16I },
            {  120, TextureFormat::R32I },
            {  121, TextureFormat::RG32I },
            {  122, TextureFormat::RGB32I },
            {  123, TextureFormat::RGBA32I },
            {  124, TextureFormat::R16F },
            {  125, TextureFormat::RG16F },
            {  126, TextureFormat::RGB16F },
            {  127, TextureFormat::RGBA16F },
            {  128, TextureFormat::R32F },
            {  129, TextureFormat::RG32F },
            {  130, TextureFormat::RGB32F },
            {  131, TextureFormat::RGBA32F },
            {  132, TextureFormat::RGB9E5 },
            {  133, TextureFormat::RG11B10F },
            {  134, TextureFormat::RG3B2 },
            {  135, TextureFormat::R5G6B5 },
            {  136, TextureFormat::RGB5A1 },
            {  137, TextureFormat::RGBA4 },
            {  138, TextureFormat::RGB10A2 },
            {  139, TextureFormat::RGB10A2U },
            {  140, TextureFormat::D16 },
            {  141, TextureFormat::D24 },
            {  142, TextureFormat::D24S8 },
            {  143, TextureFormat::D32 },
            {  144, TextureFormat::D32F },
            {  145, TextureFormat::D32FS8X24 },
            {  146, TextureFormat::RGB_DXT1 },
            {  147, TextureFormat::RGBA_DXT1 },
            {  148, TextureFormat::RGBA_DXT3 },
            {  149, TextureFormat::RGBA_DXT5 },
            {  150, TextureFormat::R_ATI1N_UNorm },
            {  151, TextureFormat::R_ATI1N_SNorm },
            {  152, TextureFormat::RG_ATI2N_UNorm },
            {  153, TextureFormat::RG_ATI2N_SNorm },
            {  154, TextureFormat::RGB_BP_UNSIGNED_FLOAT },
            {  155, TextureFormat::RGB_BP_SIGNED_FLOAT },
            {  156, TextureFormat::RGB_BP_UNorm },
            {  157, TextureFormat::R11_EAC_UNorm },
            {  158, TextureFormat::R11_EAC_SNorm },
            {  159, TextureFormat::RG11_EAC_UNorm },
            {  160, TextureFormat::RG11_EAC_SNorm },
            {  161, TextureFormat::RGB8_ETC2 },
            {  162, TextureFormat::SRGB8_ETC2 },
            {  163, TextureFormat::RGB8_PunchThrough_Alpha1_ETC2 },
            {  164, TextureFormat::SRGB8_PunchThrough_Alpha1_ETC2 },
            {  165, TextureFormat::RGBA8_ETC2_EAC },
            {  166, TextureFormat::SRGB8_Alpha8_ETC2_EAC },
            {  167, TextureFormat::RGB8_ETC1 },
            {  168, TextureFormat::SRGB8 },
            {  169, TextureFormat::SRGB8_Alpha8 },
            {  170, TextureFormat::SRGB_DXT1 },
            {  171, TextureFormat::SRGB_Alpha_DXT1 },
            {  172, TextureFormat::SRGB_Alpha_DXT3 },
            {  173, TextureFormat::SRGB_Alpha_DXT5 },
            {  174, TextureFormat::SRGB_BP_UNorm },
            {  175, TextureFormat::DepthFormat },
            {  176, TextureFormat::AlphaFormat },
            {  177, TextureFormat::RGBFormat },
            {  178, TextureFormat::RGBAFormat },
            {  179, TextureFormat::LuminanceFormat },
            {  180, TextureFormat::LuminanceAlphaFormat },
        }),
        // enum 'Filter'
        QtMocHelpers::EnumData<enum Filter>(17, 17, QMC::EnumFlags{}).add({
            {  181, Filter::Nearest },
            {  182, Filter::Linear },
            {  183, Filter::NearestMipMapNearest },
            {  184, Filter::NearestMipMapLinear },
            {  185, Filter::LinearMipMapNearest },
            {  186, Filter::LinearMipMapLinear },
        }),
        // enum 'CubeMapFace'
        QtMocHelpers::EnumData<enum CubeMapFace>(187, 187, QMC::EnumFlags{}).add({
            {  188, CubeMapFace::CubeMapPositiveX },
            {  189, CubeMapFace::CubeMapNegativeX },
            {  190, CubeMapFace::CubeMapPositiveY },
            {  191, CubeMapFace::CubeMapNegativeY },
            {  192, CubeMapFace::CubeMapPositiveZ },
            {  193, CubeMapFace::CubeMapNegativeZ },
            {  194, CubeMapFace::AllFaces },
        }),
        // enum 'ComparisonFunction'
        QtMocHelpers::EnumData<enum ComparisonFunction>(24, 24, QMC::EnumFlags{}).add({
            {  195, ComparisonFunction::CompareLessEqual },
            {  196, ComparisonFunction::CompareGreaterEqual },
            {  197, ComparisonFunction::CompareLess },
            {  198, ComparisonFunction::CompareGreater },
            {  199, ComparisonFunction::CompareEqual },
            {  200, ComparisonFunction::CommpareNotEqual },
            {  201, ComparisonFunction::CompareAlways },
            {  202, ComparisonFunction::CompareNever },
        }),
        // enum 'ComparisonMode'
        QtMocHelpers::EnumData<enum ComparisonMode>(27, 27, QMC::EnumFlags{}).add({
            {  203, ComparisonMode::CompareRefToTexture },
            {  204, ComparisonMode::CompareNone },
        }),
        // enum 'HandleType'
        QtMocHelpers::EnumData<enum HandleType>(34, 34, QMC::EnumFlags{}).add({
            {  205, HandleType::NoHandle },
            {  206, HandleType::OpenGLTextureId },
            {  207, HandleType::RHITextureId },
        }),
    };
    return QtMocHelpers::metaObjectData<QAbstractTexture, qt_meta_tag_ZN10Qt3DRender16QAbstractTextureE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Qt3DRender::QAbstractTexture::staticMetaObject = { {
    QMetaObject::SuperData::link<Qt3DCore::QNode::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10Qt3DRender16QAbstractTextureE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10Qt3DRender16QAbstractTextureE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN10Qt3DRender16QAbstractTextureE_t>.metaTypes,
    nullptr
} };

void Qt3DRender::QAbstractTexture::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QAbstractTexture *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->formatChanged((*reinterpret_cast<std::add_pointer_t<enum TextureFormat>>(_a[1]))); break;
        case 1: _t->statusChanged((*reinterpret_cast<std::add_pointer_t<enum Status>>(_a[1]))); break;
        case 2: _t->generateMipMapsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 3: _t->widthChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 4: _t->heightChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 5: _t->depthChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 6: _t->magnificationFilterChanged((*reinterpret_cast<std::add_pointer_t<enum Filter>>(_a[1]))); break;
        case 7: _t->minificationFilterChanged((*reinterpret_cast<std::add_pointer_t<enum Filter>>(_a[1]))); break;
        case 8: _t->maximumAnisotropyChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 9: _t->comparisonFunctionChanged((*reinterpret_cast<std::add_pointer_t<enum ComparisonFunction>>(_a[1]))); break;
        case 10: _t->comparisonModeChanged((*reinterpret_cast<std::add_pointer_t<enum ComparisonMode>>(_a[1]))); break;
        case 11: _t->layersChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 12: _t->samplesChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 13: _t->handleTypeChanged((*reinterpret_cast<std::add_pointer_t<enum HandleType>>(_a[1]))); break;
        case 14: _t->handleChanged((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 15: _t->mipLevelsChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 16: _t->setFormat((*reinterpret_cast<std::add_pointer_t<enum TextureFormat>>(_a[1]))); break;
        case 17: _t->setGenerateMipMaps((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 18: _t->setWidth((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 19: _t->setHeight((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 20: _t->setDepth((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 21: _t->setMinificationFilter((*reinterpret_cast<std::add_pointer_t<enum Filter>>(_a[1]))); break;
        case 22: _t->setMagnificationFilter((*reinterpret_cast<std::add_pointer_t<enum Filter>>(_a[1]))); break;
        case 23: _t->setMaximumAnisotropy((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 24: _t->setComparisonFunction((*reinterpret_cast<std::add_pointer_t<enum ComparisonFunction>>(_a[1]))); break;
        case 25: _t->setComparisonMode((*reinterpret_cast<std::add_pointer_t<enum ComparisonMode>>(_a[1]))); break;
        case 26: _t->setLayers((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 27: _t->setSamples((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 28: _t->setMipLevels((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 29: _t->updateData((*reinterpret_cast<std::add_pointer_t<QTextureDataUpdate>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (QAbstractTexture::*)(TextureFormat )>(_a, &QAbstractTexture::formatChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (QAbstractTexture::*)(Status )>(_a, &QAbstractTexture::statusChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (QAbstractTexture::*)(bool )>(_a, &QAbstractTexture::generateMipMapsChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (QAbstractTexture::*)(int )>(_a, &QAbstractTexture::widthChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (QAbstractTexture::*)(int )>(_a, &QAbstractTexture::heightChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (QAbstractTexture::*)(int )>(_a, &QAbstractTexture::depthChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (QAbstractTexture::*)(Filter )>(_a, &QAbstractTexture::magnificationFilterChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (QAbstractTexture::*)(Filter )>(_a, &QAbstractTexture::minificationFilterChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (QAbstractTexture::*)(float )>(_a, &QAbstractTexture::maximumAnisotropyChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (QAbstractTexture::*)(ComparisonFunction )>(_a, &QAbstractTexture::comparisonFunctionChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (QAbstractTexture::*)(ComparisonMode )>(_a, &QAbstractTexture::comparisonModeChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (QAbstractTexture::*)(int )>(_a, &QAbstractTexture::layersChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (QAbstractTexture::*)(int )>(_a, &QAbstractTexture::samplesChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (QAbstractTexture::*)(HandleType )>(_a, &QAbstractTexture::handleTypeChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (QAbstractTexture::*)(QVariant )>(_a, &QAbstractTexture::handleChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (QAbstractTexture::*)(int )>(_a, &QAbstractTexture::mipLevelsChanged, 15))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 3:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Qt3DRender::QTextureWrapMode* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<enum Target*>(_v) = _t->target(); break;
        case 1: *reinterpret_cast<enum TextureFormat*>(_v) = _t->format(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->generateMipMaps(); break;
        case 3: *reinterpret_cast<Qt3DRender::QTextureWrapMode**>(_v) = _t->wrapMode(); break;
        case 4: *reinterpret_cast<enum Status*>(_v) = _t->status(); break;
        case 5: *reinterpret_cast<int*>(_v) = _t->width(); break;
        case 6: *reinterpret_cast<int*>(_v) = _t->height(); break;
        case 7: *reinterpret_cast<int*>(_v) = _t->depth(); break;
        case 8: *reinterpret_cast<int*>(_v) = _t->mipLevels(); break;
        case 9: *reinterpret_cast<enum Filter*>(_v) = _t->magnificationFilter(); break;
        case 10: *reinterpret_cast<enum Filter*>(_v) = _t->minificationFilter(); break;
        case 11: *reinterpret_cast<float*>(_v) = _t->maximumAnisotropy(); break;
        case 12: *reinterpret_cast<enum ComparisonFunction*>(_v) = _t->comparisonFunction(); break;
        case 13: *reinterpret_cast<enum ComparisonMode*>(_v) = _t->comparisonMode(); break;
        case 14: *reinterpret_cast<int*>(_v) = _t->layers(); break;
        case 15: *reinterpret_cast<int*>(_v) = _t->samples(); break;
        case 16: *reinterpret_cast<enum HandleType*>(_v) = _t->handleType(); break;
        case 17: *reinterpret_cast<QVariant*>(_v) = _t->handle(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 1: _t->setFormat(*reinterpret_cast<enum TextureFormat*>(_v)); break;
        case 2: _t->setGenerateMipMaps(*reinterpret_cast<bool*>(_v)); break;
        case 5: _t->setWidth(*reinterpret_cast<int*>(_v)); break;
        case 6: _t->setHeight(*reinterpret_cast<int*>(_v)); break;
        case 7: _t->setDepth(*reinterpret_cast<int*>(_v)); break;
        case 8: _t->setMipLevels(*reinterpret_cast<int*>(_v)); break;
        case 9: _t->setMagnificationFilter(*reinterpret_cast<enum Filter*>(_v)); break;
        case 10: _t->setMinificationFilter(*reinterpret_cast<enum Filter*>(_v)); break;
        case 11: _t->setMaximumAnisotropy(*reinterpret_cast<float*>(_v)); break;
        case 12: _t->setComparisonFunction(*reinterpret_cast<enum ComparisonFunction*>(_v)); break;
        case 13: _t->setComparisonMode(*reinterpret_cast<enum ComparisonMode*>(_v)); break;
        case 14: _t->setLayers(*reinterpret_cast<int*>(_v)); break;
        case 15: _t->setSamples(*reinterpret_cast<int*>(_v)); break;
        default: break;
        }
    }
}

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

void *Qt3DRender::QAbstractTexture::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10Qt3DRender16QAbstractTextureE_t>.strings))
        return static_cast<void*>(this);
    return Qt3DCore::QNode::qt_metacast(_clname);
}

int Qt3DRender::QAbstractTexture::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Qt3DCore::QNode::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 30)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 30;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 30)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 30;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 18;
    }
    return _id;
}

// SIGNAL 0
void Qt3DRender::QAbstractTexture::formatChanged(TextureFormat _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void Qt3DRender::QAbstractTexture::statusChanged(Status _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

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

// SIGNAL 3
void Qt3DRender::QAbstractTexture::widthChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void Qt3DRender::QAbstractTexture::heightChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void Qt3DRender::QAbstractTexture::depthChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void Qt3DRender::QAbstractTexture::magnificationFilterChanged(Filter _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void Qt3DRender::QAbstractTexture::minificationFilterChanged(Filter _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void Qt3DRender::QAbstractTexture::maximumAnisotropyChanged(float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void Qt3DRender::QAbstractTexture::comparisonFunctionChanged(ComparisonFunction _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void Qt3DRender::QAbstractTexture::comparisonModeChanged(ComparisonMode _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void Qt3DRender::QAbstractTexture::layersChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void Qt3DRender::QAbstractTexture::samplesChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void Qt3DRender::QAbstractTexture::handleTypeChanged(HandleType _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void Qt3DRender::QAbstractTexture::handleChanged(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void Qt3DRender::QAbstractTexture::mipLevelsChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}
QT_WARNING_POP
