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

#include "../../../../../qtbase/src/opengl/qopengltexture.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 'qopengltexture.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.10.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_ZN14QOpenGLTextureE_t {};
} // unnamed namespace

template <> constexpr inline auto QOpenGLTexture::qt_create_metaobjectdata<qt_meta_tag_ZN14QOpenGLTextureE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QOpenGLTexture",
        "Target",
        "Target1D",
        "Target1DArray",
        "Target2D",
        "Target2DArray",
        "Target3D",
        "TargetCubeMap",
        "TargetCubeMapArray",
        "Target2DMultisample",
        "Target2DMultisampleArray",
        "TargetRectangle",
        "TargetBuffer",
        "BindingTarget",
        "BindingTarget1D",
        "BindingTarget1DArray",
        "BindingTarget2D",
        "BindingTarget2DArray",
        "BindingTarget3D",
        "BindingTargetCubeMap",
        "BindingTargetCubeMapArray",
        "BindingTarget2DMultisample",
        "BindingTarget2DMultisampleArray",
        "BindingTargetRectangle",
        "BindingTargetBuffer",
        "MipMapGeneration",
        "GenerateMipMaps",
        "DontGenerateMipMaps",
        "TextureUnitReset",
        "ResetTextureUnit",
        "DontResetTextureUnit",
        "TextureFormat",
        "NoFormat",
        "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",
        "D16",
        "D24",
        "D24S8",
        "D32",
        "D32F",
        "D32FS8X24",
        "S8",
        "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",
        "RGBA_ASTC_4x4",
        "RGBA_ASTC_5x4",
        "RGBA_ASTC_5x5",
        "RGBA_ASTC_6x5",
        "RGBA_ASTC_6x6",
        "RGBA_ASTC_8x5",
        "RGBA_ASTC_8x6",
        "RGBA_ASTC_8x8",
        "RGBA_ASTC_10x5",
        "RGBA_ASTC_10x6",
        "RGBA_ASTC_10x8",
        "RGBA_ASTC_10x10",
        "RGBA_ASTC_12x10",
        "RGBA_ASTC_12x12",
        "SRGB8_Alpha8_ASTC_4x4",
        "SRGB8_Alpha8_ASTC_5x4",
        "SRGB8_Alpha8_ASTC_5x5",
        "SRGB8_Alpha8_ASTC_6x5",
        "SRGB8_Alpha8_ASTC_6x6",
        "SRGB8_Alpha8_ASTC_8x5",
        "SRGB8_Alpha8_ASTC_8x6",
        "SRGB8_Alpha8_ASTC_8x8",
        "SRGB8_Alpha8_ASTC_10x5",
        "SRGB8_Alpha8_ASTC_10x6",
        "SRGB8_Alpha8_ASTC_10x8",
        "SRGB8_Alpha8_ASTC_10x10",
        "SRGB8_Alpha8_ASTC_12x10",
        "SRGB8_Alpha8_ASTC_12x12",
        "SRGB8",
        "SRGB8_Alpha8",
        "SRGB_DXT1",
        "SRGB_Alpha_DXT1",
        "SRGB_Alpha_DXT3",
        "SRGB_Alpha_DXT5",
        "SRGB_BP_UNorm",
        "DepthFormat",
        "AlphaFormat",
        "RGBFormat",
        "RGBAFormat",
        "LuminanceFormat",
        "LuminanceAlphaFormat",
        "CubeMapFace",
        "CubeMapPositiveX",
        "CubeMapNegativeX",
        "CubeMapPositiveY",
        "CubeMapNegativeY",
        "CubeMapPositiveZ",
        "CubeMapNegativeZ",
        "PixelFormat",
        "NoSourceFormat",
        "Red",
        "RG",
        "RGB",
        "BGR",
        "RGBA",
        "BGRA",
        "Red_Integer",
        "RG_Integer",
        "RGB_Integer",
        "BGR_Integer",
        "RGBA_Integer",
        "BGRA_Integer",
        "Stencil",
        "Depth",
        "DepthStencil",
        "Alpha",
        "Luminance",
        "LuminanceAlpha",
        "PixelType",
        "NoPixelType",
        "Int8",
        "UInt8",
        "Int16",
        "UInt16",
        "Int32",
        "UInt32",
        "Float16",
        "Float16OES",
        "Float32",
        "UInt32_RGB9_E5",
        "UInt32_RG11B10F",
        "UInt8_RG3B2",
        "UInt8_RG3B2_Rev",
        "UInt16_RGB5A1",
        "UInt16_RGB5A1_Rev",
        "UInt16_R5G6B5",
        "UInt16_R5G6B5_Rev",
        "UInt16_RGBA4",
        "UInt16_RGBA4_Rev",
        "UInt32_RGBA8",
        "UInt32_RGBA8_Rev",
        "UInt32_RGB10A2",
        "UInt32_RGB10A2_Rev",
        "UInt32_D24S8",
        "Float32_D32_UInt32_S8_X24",
        "SwizzleComponent",
        "SwizzleRed",
        "SwizzleGreen",
        "SwizzleBlue",
        "SwizzleAlpha",
        "SwizzleValue",
        "RedValue",
        "GreenValue",
        "BlueValue",
        "AlphaValue",
        "ZeroValue",
        "OneValue",
        "WrapMode",
        "Repeat",
        "MirroredRepeat",
        "ClampToEdge",
        "ClampToBorder",
        "CoordinateDirection",
        "DirectionS",
        "DirectionT",
        "DirectionR",
        "Feature",
        "ImmutableStorage",
        "ImmutableMultisampleStorage",
        "TextureRectangle",
        "TextureArrays",
        "Texture3D",
        "TextureMultisample",
        "TextureBuffer",
        "TextureCubeMapArrays",
        "Swizzle",
        "StencilTexturing",
        "AnisotropicFiltering",
        "NPOTTextures",
        "NPOTTextureRepeat",
        "Texture1D",
        "TextureComparisonOperators",
        "TextureMipMapLevel",
        "MaxFeatureFlag",
        "DepthStencilMode",
        "DepthMode",
        "StencilMode",
        "ComparisonFunction",
        "CompareLessEqual",
        "CompareGreaterEqual",
        "CompareLess",
        "CompareGreater",
        "CompareEqual",
        "CompareNotEqual",
        "CompareAlways",
        "CompareNever",
        "CommpareNotEqual",
        "Filter",
        "Nearest",
        "Linear",
        "NearestMipMapNearest",
        "NearestMipMapLinear",
        "LinearMipMapNearest",
        "LinearMipMapLinear"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Target'
        QtMocHelpers::EnumData<enum Target>(1, 1, QMC::EnumFlags{}).add({
            {    2, Target::Target1D },
            {    3, Target::Target1DArray },
            {    4, Target::Target2D },
            {    5, Target::Target2DArray },
            {    6, Target::Target3D },
            {    7, Target::TargetCubeMap },
            {    8, Target::TargetCubeMapArray },
            {    9, Target::Target2DMultisample },
            {   10, Target::Target2DMultisampleArray },
            {   11, Target::TargetRectangle },
            {   12, Target::TargetBuffer },
        }),
        // enum 'BindingTarget'
        QtMocHelpers::EnumData<enum BindingTarget>(13, 13, QMC::EnumFlags{}).add({
            {   14, BindingTarget::BindingTarget1D },
            {   15, BindingTarget::BindingTarget1DArray },
            {   16, BindingTarget::BindingTarget2D },
            {   17, BindingTarget::BindingTarget2DArray },
            {   18, BindingTarget::BindingTarget3D },
            {   19, BindingTarget::BindingTargetCubeMap },
            {   20, BindingTarget::BindingTargetCubeMapArray },
            {   21, BindingTarget::BindingTarget2DMultisample },
            {   22, BindingTarget::BindingTarget2DMultisampleArray },
            {   23, BindingTarget::BindingTargetRectangle },
            {   24, BindingTarget::BindingTargetBuffer },
        }),
        // enum 'MipMapGeneration'
        QtMocHelpers::EnumData<enum MipMapGeneration>(25, 25, QMC::EnumFlags{}).add({
            {   26, MipMapGeneration::GenerateMipMaps },
            {   27, MipMapGeneration::DontGenerateMipMaps },
        }),
        // enum 'TextureUnitReset'
        QtMocHelpers::EnumData<enum TextureUnitReset>(28, 28, QMC::EnumFlags{}).add({
            {   29, TextureUnitReset::ResetTextureUnit },
            {   30, TextureUnitReset::DontResetTextureUnit },
        }),
        // enum 'TextureFormat'
        QtMocHelpers::EnumData<enum TextureFormat>(31, 31, QMC::EnumFlags{}).add({
            {   32, TextureFormat::NoFormat },
            {   33, TextureFormat::R8_UNorm },
            {   34, TextureFormat::RG8_UNorm },
            {   35, TextureFormat::RGB8_UNorm },
            {   36, TextureFormat::RGBA8_UNorm },
            {   37, TextureFormat::R16_UNorm },
            {   38, TextureFormat::RG16_UNorm },
            {   39, TextureFormat::RGB16_UNorm },
            {   40, TextureFormat::RGBA16_UNorm },
            {   41, TextureFormat::R8_SNorm },
            {   42, TextureFormat::RG8_SNorm },
            {   43, TextureFormat::RGB8_SNorm },
            {   44, TextureFormat::RGBA8_SNorm },
            {   45, TextureFormat::R16_SNorm },
            {   46, TextureFormat::RG16_SNorm },
            {   47, TextureFormat::RGB16_SNorm },
            {   48, TextureFormat::RGBA16_SNorm },
            {   49, TextureFormat::R8U },
            {   50, TextureFormat::RG8U },
            {   51, TextureFormat::RGB8U },
            {   52, TextureFormat::RGBA8U },
            {   53, TextureFormat::R16U },
            {   54, TextureFormat::RG16U },
            {   55, TextureFormat::RGB16U },
            {   56, TextureFormat::RGBA16U },
            {   57, TextureFormat::R32U },
            {   58, TextureFormat::RG32U },
            {   59, TextureFormat::RGB32U },
            {   60, TextureFormat::RGBA32U },
            {   61, TextureFormat::R8I },
            {   62, TextureFormat::RG8I },
            {   63, TextureFormat::RGB8I },
            {   64, TextureFormat::RGBA8I },
            {   65, TextureFormat::R16I },
            {   66, TextureFormat::RG16I },
            {   67, TextureFormat::RGB16I },
            {   68, TextureFormat::RGBA16I },
            {   69, TextureFormat::R32I },
            {   70, TextureFormat::RG32I },
            {   71, TextureFormat::RGB32I },
            {   72, TextureFormat::RGBA32I },
            {   73, TextureFormat::R16F },
            {   74, TextureFormat::RG16F },
            {   75, TextureFormat::RGB16F },
            {   76, TextureFormat::RGBA16F },
            {   77, TextureFormat::R32F },
            {   78, TextureFormat::RG32F },
            {   79, TextureFormat::RGB32F },
            {   80, TextureFormat::RGBA32F },
            {   81, TextureFormat::RGB9E5 },
            {   82, TextureFormat::RG11B10F },
            {   83, TextureFormat::RG3B2 },
            {   84, TextureFormat::R5G6B5 },
            {   85, TextureFormat::RGB5A1 },
            {   86, TextureFormat::RGBA4 },
            {   87, TextureFormat::RGB10A2 },
            {   88, TextureFormat::D16 },
            {   89, TextureFormat::D24 },
            {   90, TextureFormat::D24S8 },
            {   91, TextureFormat::D32 },
            {   92, TextureFormat::D32F },
            {   93, TextureFormat::D32FS8X24 },
            {   94, TextureFormat::S8 },
            {   95, TextureFormat::RGB_DXT1 },
            {   96, TextureFormat::RGBA_DXT1 },
            {   97, TextureFormat::RGBA_DXT3 },
            {   98, TextureFormat::RGBA_DXT5 },
            {   99, TextureFormat::R_ATI1N_UNorm },
            {  100, TextureFormat::R_ATI1N_SNorm },
            {  101, TextureFormat::RG_ATI2N_UNorm },
            {  102, TextureFormat::RG_ATI2N_SNorm },
            {  103, TextureFormat::RGB_BP_UNSIGNED_FLOAT },
            {  104, TextureFormat::RGB_BP_SIGNED_FLOAT },
            {  105, TextureFormat::RGB_BP_UNorm },
            {  106, TextureFormat::R11_EAC_UNorm },
            {  107, TextureFormat::R11_EAC_SNorm },
            {  108, TextureFormat::RG11_EAC_UNorm },
            {  109, TextureFormat::RG11_EAC_SNorm },
            {  110, TextureFormat::RGB8_ETC2 },
            {  111, TextureFormat::SRGB8_ETC2 },
            {  112, TextureFormat::RGB8_PunchThrough_Alpha1_ETC2 },
            {  113, TextureFormat::SRGB8_PunchThrough_Alpha1_ETC2 },
            {  114, TextureFormat::RGBA8_ETC2_EAC },
            {  115, TextureFormat::SRGB8_Alpha8_ETC2_EAC },
            {  116, TextureFormat::RGB8_ETC1 },
            {  117, TextureFormat::RGBA_ASTC_4x4 },
            {  118, TextureFormat::RGBA_ASTC_5x4 },
            {  119, TextureFormat::RGBA_ASTC_5x5 },
            {  120, TextureFormat::RGBA_ASTC_6x5 },
            {  121, TextureFormat::RGBA_ASTC_6x6 },
            {  122, TextureFormat::RGBA_ASTC_8x5 },
            {  123, TextureFormat::RGBA_ASTC_8x6 },
            {  124, TextureFormat::RGBA_ASTC_8x8 },
            {  125, TextureFormat::RGBA_ASTC_10x5 },
            {  126, TextureFormat::RGBA_ASTC_10x6 },
            {  127, TextureFormat::RGBA_ASTC_10x8 },
            {  128, TextureFormat::RGBA_ASTC_10x10 },
            {  129, TextureFormat::RGBA_ASTC_12x10 },
            {  130, TextureFormat::RGBA_ASTC_12x12 },
            {  131, TextureFormat::SRGB8_Alpha8_ASTC_4x4 },
            {  132, TextureFormat::SRGB8_Alpha8_ASTC_5x4 },
            {  133, TextureFormat::SRGB8_Alpha8_ASTC_5x5 },
            {  134, TextureFormat::SRGB8_Alpha8_ASTC_6x5 },
            {  135, TextureFormat::SRGB8_Alpha8_ASTC_6x6 },
            {  136, TextureFormat::SRGB8_Alpha8_ASTC_8x5 },
            {  137, TextureFormat::SRGB8_Alpha8_ASTC_8x6 },
            {  138, TextureFormat::SRGB8_Alpha8_ASTC_8x8 },
            {  139, TextureFormat::SRGB8_Alpha8_ASTC_10x5 },
            {  140, TextureFormat::SRGB8_Alpha8_ASTC_10x6 },
            {  141, TextureFormat::SRGB8_Alpha8_ASTC_10x8 },
            {  142, TextureFormat::SRGB8_Alpha8_ASTC_10x10 },
            {  143, TextureFormat::SRGB8_Alpha8_ASTC_12x10 },
            {  144, TextureFormat::SRGB8_Alpha8_ASTC_12x12 },
            {  145, TextureFormat::SRGB8 },
            {  146, TextureFormat::SRGB8_Alpha8 },
            {  147, TextureFormat::SRGB_DXT1 },
            {  148, TextureFormat::SRGB_Alpha_DXT1 },
            {  149, TextureFormat::SRGB_Alpha_DXT3 },
            {  150, TextureFormat::SRGB_Alpha_DXT5 },
            {  151, TextureFormat::SRGB_BP_UNorm },
            {  152, TextureFormat::DepthFormat },
            {  153, TextureFormat::AlphaFormat },
            {  154, TextureFormat::RGBFormat },
            {  155, TextureFormat::RGBAFormat },
            {  156, TextureFormat::LuminanceFormat },
            {  157, TextureFormat::LuminanceAlphaFormat },
        }),
        // enum 'CubeMapFace'
        QtMocHelpers::EnumData<enum CubeMapFace>(158, 158, QMC::EnumFlags{}).add({
            {  159, CubeMapFace::CubeMapPositiveX },
            {  160, CubeMapFace::CubeMapNegativeX },
            {  161, CubeMapFace::CubeMapPositiveY },
            {  162, CubeMapFace::CubeMapNegativeY },
            {  163, CubeMapFace::CubeMapPositiveZ },
            {  164, CubeMapFace::CubeMapNegativeZ },
        }),
        // enum 'PixelFormat'
        QtMocHelpers::EnumData<enum PixelFormat>(165, 165, QMC::EnumFlags{}).add({
            {  166, PixelFormat::NoSourceFormat },
            {  167, PixelFormat::Red },
            {  168, PixelFormat::RG },
            {  169, PixelFormat::RGB },
            {  170, PixelFormat::BGR },
            {  171, PixelFormat::RGBA },
            {  172, PixelFormat::BGRA },
            {  173, PixelFormat::Red_Integer },
            {  174, PixelFormat::RG_Integer },
            {  175, PixelFormat::RGB_Integer },
            {  176, PixelFormat::BGR_Integer },
            {  177, PixelFormat::RGBA_Integer },
            {  178, PixelFormat::BGRA_Integer },
            {  179, PixelFormat::Stencil },
            {  180, PixelFormat::Depth },
            {  181, PixelFormat::DepthStencil },
            {  182, PixelFormat::Alpha },
            {  183, PixelFormat::Luminance },
            {  184, PixelFormat::LuminanceAlpha },
        }),
        // enum 'PixelType'
        QtMocHelpers::EnumData<enum PixelType>(185, 185, QMC::EnumFlags{}).add({
            {  186, PixelType::NoPixelType },
            {  187, PixelType::Int8 },
            {  188, PixelType::UInt8 },
            {  189, PixelType::Int16 },
            {  190, PixelType::UInt16 },
            {  191, PixelType::Int32 },
            {  192, PixelType::UInt32 },
            {  193, PixelType::Float16 },
            {  194, PixelType::Float16OES },
            {  195, PixelType::Float32 },
            {  196, PixelType::UInt32_RGB9_E5 },
            {  197, PixelType::UInt32_RG11B10F },
            {  198, PixelType::UInt8_RG3B2 },
            {  199, PixelType::UInt8_RG3B2_Rev },
            {  200, PixelType::UInt16_RGB5A1 },
            {  201, PixelType::UInt16_RGB5A1_Rev },
            {  202, PixelType::UInt16_R5G6B5 },
            {  203, PixelType::UInt16_R5G6B5_Rev },
            {  204, PixelType::UInt16_RGBA4 },
            {  205, PixelType::UInt16_RGBA4_Rev },
            {  206, PixelType::UInt32_RGBA8 },
            {  207, PixelType::UInt32_RGBA8_Rev },
            {  208, PixelType::UInt32_RGB10A2 },
            {  209, PixelType::UInt32_RGB10A2_Rev },
            {  210, PixelType::UInt32_D24S8 },
            {  211, PixelType::Float32_D32_UInt32_S8_X24 },
        }),
        // enum 'SwizzleComponent'
        QtMocHelpers::EnumData<enum SwizzleComponent>(212, 212, QMC::EnumFlags{}).add({
            {  213, SwizzleComponent::SwizzleRed },
            {  214, SwizzleComponent::SwizzleGreen },
            {  215, SwizzleComponent::SwizzleBlue },
            {  216, SwizzleComponent::SwizzleAlpha },
        }),
        // enum 'SwizzleValue'
        QtMocHelpers::EnumData<enum SwizzleValue>(217, 217, QMC::EnumFlags{}).add({
            {  218, SwizzleValue::RedValue },
            {  219, SwizzleValue::GreenValue },
            {  220, SwizzleValue::BlueValue },
            {  221, SwizzleValue::AlphaValue },
            {  222, SwizzleValue::ZeroValue },
            {  223, SwizzleValue::OneValue },
        }),
        // enum 'WrapMode'
        QtMocHelpers::EnumData<enum WrapMode>(224, 224, QMC::EnumFlags{}).add({
            {  225, WrapMode::Repeat },
            {  226, WrapMode::MirroredRepeat },
            {  227, WrapMode::ClampToEdge },
            {  228, WrapMode::ClampToBorder },
        }),
        // enum 'CoordinateDirection'
        QtMocHelpers::EnumData<enum CoordinateDirection>(229, 229, QMC::EnumFlags{}).add({
            {  230, CoordinateDirection::DirectionS },
            {  231, CoordinateDirection::DirectionT },
            {  232, CoordinateDirection::DirectionR },
        }),
        // enum 'Feature'
        QtMocHelpers::EnumData<enum Feature>(233, 233, QMC::EnumFlags{}).add({
            {  234, Feature::ImmutableStorage },
            {  235, Feature::ImmutableMultisampleStorage },
            {  236, Feature::TextureRectangle },
            {  237, Feature::TextureArrays },
            {  238, Feature::Texture3D },
            {  239, Feature::TextureMultisample },
            {  240, Feature::TextureBuffer },
            {  241, Feature::TextureCubeMapArrays },
            {  242, Feature::Swizzle },
            {  243, Feature::StencilTexturing },
            {  244, Feature::AnisotropicFiltering },
            {  245, Feature::NPOTTextures },
            {  246, Feature::NPOTTextureRepeat },
            {  247, Feature::Texture1D },
            {  248, Feature::TextureComparisonOperators },
            {  249, Feature::TextureMipMapLevel },
            {  250, Feature::MaxFeatureFlag },
        }),
        // enum 'DepthStencilMode'
        QtMocHelpers::EnumData<enum DepthStencilMode>(251, 251, QMC::EnumFlags{}).add({
            {  252, DepthStencilMode::DepthMode },
            {  253, DepthStencilMode::StencilMode },
        }),
        // enum 'ComparisonFunction'
        QtMocHelpers::EnumData<enum ComparisonFunction>(254, 254, QMC::EnumFlags{}).add({
            {  255, ComparisonFunction::CompareLessEqual },
            {  256, ComparisonFunction::CompareGreaterEqual },
            {  257, ComparisonFunction::CompareLess },
            {  258, ComparisonFunction::CompareGreater },
            {  259, ComparisonFunction::CompareEqual },
            {  260, ComparisonFunction::CompareNotEqual },
            {  261, ComparisonFunction::CompareAlways },
            {  262, ComparisonFunction::CompareNever },
            {  263, ComparisonFunction::CommpareNotEqual },
        }),
        // enum 'Filter'
        QtMocHelpers::EnumData<enum Filter>(264, 264, QMC::EnumFlags{}).add({
            {  265, Filter::Nearest },
            {  266, Filter::Linear },
            {  267, Filter::NearestMipMapNearest },
            {  268, Filter::NearestMipMapLinear },
            {  269, Filter::LinearMipMapNearest },
            {  270, Filter::LinearMipMapLinear },
        }),
    };
    return QtMocHelpers::metaObjectData<QOpenGLTexture, qt_meta_tag_ZN14QOpenGLTextureE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QOpenGLTexture::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QOpenGLTextureE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QOpenGLTextureE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14QOpenGLTextureE_t>.metaTypes,
    nullptr
} };

QT_WARNING_POP
