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

#include "../../../../../qtquick3d/src/quick3d/qquick3dsceneenvironment_p.h"
#include <QtNetwork/QSslError>
#include <QtGui/qtextcursor.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 'qquick3dsceneenvironment_p.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.2. 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_ZN24QQuick3DSceneEnvironmentE_t {};
} // unnamed namespace

template <> constexpr inline auto QQuick3DSceneEnvironment::qt_create_metaobjectdata<qt_meta_tag_ZN24QQuick3DSceneEnvironmentE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QQuick3DSceneEnvironment",
        "QML.Element",
        "SceneEnvironment",
        "antialiasingModeChanged",
        "",
        "antialiasingQualityChanged",
        "temporalAAModeChanged",
        "temporalAAEnabledChanged",
        "temporalAAStrengthChanged",
        "backgroundModeChanged",
        "clearColorChanged",
        "aoStrengthChanged",
        "aoDistanceChanged",
        "aoSoftnessChanged",
        "aoDitherChanged",
        "aoSampleRateChanged",
        "aoBiasChanged",
        "aoEnabledChanged",
        "lightProbeChanged",
        "probeExposureChanged",
        "probeHorizonChanged",
        "probeOrientationChanged",
        "depthTestEnabledChanged",
        "depthPrePassEnabledChanged",
        "tonemapModeChanged",
        "skyboxBlurAmountChanged",
        "specularAAEnabledChanged",
        "lightmapperChanged",
        "skyBoxCubeMapChanged",
        "debugSettingsChanged",
        "scissorRectChanged",
        "fogChanged",
        "oitMethodChanged",
        "setAntialiasingMode",
        "QQuick3DSceneEnvironment::QQuick3DEnvironmentAAModeValues",
        "antialiasingMode",
        "setAntialiasingQuality",
        "QQuick3DSceneEnvironment::QQuick3DEnvironmentAAQualityValues",
        "antialiasingQuality",
        "setTemporalAAMode",
        "QQuick3DEnvironmentTemporalAAMode",
        "newTemporalAAMode",
        "setTemporalAAEnabled",
        "temporalAAEnabled",
        "setTemporalAAStrength",
        "strength",
        "setBackgroundMode",
        "QQuick3DSceneEnvironment::QQuick3DEnvironmentBackgroundTypes",
        "backgroundMode",
        "setClearColor",
        "QColor",
        "clearColor",
        "setAoStrength",
        "aoStrength",
        "setAoDistance",
        "aoDistance",
        "setAoSoftness",
        "aoSoftness",
        "setAoDither",
        "aoDither",
        "setAoSampleRate",
        "aoSampleRate",
        "setAoBias",
        "aoBias",
        "setLightProbe",
        "QQuick3DTexture*",
        "lightProbe",
        "setProbeExposure",
        "probeExposure",
        "setProbeHorizon",
        "probeHorizon",
        "setProbeOrientation",
        "QVector3D",
        "orientation",
        "setDepthTestEnabled",
        "depthTestEnabled",
        "setDepthPrePassEnabled",
        "depthPrePassEnabled",
        "setTonemapMode",
        "QQuick3DSceneEnvironment::QQuick3DEnvironmentTonemapModes",
        "tonemapMode",
        "setSkyboxBlurAmount",
        "newSkyboxBlurAmount",
        "setSpecularAAEnabled",
        "enabled",
        "setSkyBoxCubeMap",
        "QQuick3DCubeMapTexture*",
        "newSkyBoxCubeMap",
        "setLightmapper",
        "QQuick3DLightmapper*",
        "lightmapper",
        "setDebugSettings",
        "QQuick3DDebugSettings*",
        "newDebugSettings",
        "setScissorRect",
        "QRect",
        "scissorRect",
        "setFog",
        "QQuick3DFog*",
        "fog",
        "setOitMethod",
        "QQuick3DSceneEnvironment::QQuick3DEnvironmentOITMethod",
        "mode",
        "QQuick3DEnvironmentAAModeValues",
        "QQuick3DEnvironmentAAQualityValues",
        "temporalAAMode",
        "temporalAAStrength",
        "QQuick3DEnvironmentBackgroundTypes",
        "aoEnabled",
        "probeOrientation",
        "skyBoxCubeMap",
        "QQuick3DEnvironmentTonemapModes",
        "effects",
        "QQmlListProperty<QQuick3DEffect>",
        "skyboxBlurAmount",
        "specularAAEnabled",
        "debugSettings",
        "oitMethod",
        "QQuick3DEnvironmentOITMethod",
        "NoAA",
        "SSAA",
        "MSAA",
        "ProgressiveAA",
        "Medium",
        "High",
        "VeryHigh",
        "Transparent",
        "Unspecified",
        "Color",
        "SkyBox",
        "SkyBoxCubeMap",
        "TonemapModeNone",
        "TonemapModeLinear",
        "TonemapModeAces",
        "TonemapModeHejlDawson",
        "TonemapModeFilmic",
        "OITNone",
        "OITWeightedBlended",
        "OITLinkedList",
        "TAADefault",
        "TAAMotionVector"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'antialiasingModeChanged'
        QtMocHelpers::SignalData<void()>(3, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'antialiasingQualityChanged'
        QtMocHelpers::SignalData<void()>(5, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'temporalAAModeChanged'
        QtMocHelpers::RevisionedSignalData<void()>(6, 4, QMC::AccessPublic, 0x60b, QMetaType::Void),
        // Signal 'temporalAAEnabledChanged'
        QtMocHelpers::SignalData<void()>(7, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'temporalAAStrengthChanged'
        QtMocHelpers::SignalData<void()>(8, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'backgroundModeChanged'
        QtMocHelpers::SignalData<void()>(9, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'clearColorChanged'
        QtMocHelpers::SignalData<void()>(10, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'aoStrengthChanged'
        QtMocHelpers::SignalData<void()>(11, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'aoDistanceChanged'
        QtMocHelpers::SignalData<void()>(12, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'aoSoftnessChanged'
        QtMocHelpers::SignalData<void()>(13, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'aoDitherChanged'
        QtMocHelpers::SignalData<void()>(14, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'aoSampleRateChanged'
        QtMocHelpers::SignalData<void()>(15, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'aoBiasChanged'
        QtMocHelpers::SignalData<void()>(16, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'aoEnabledChanged'
        QtMocHelpers::RevisionedSignalData<void()>(17, 4, QMC::AccessPublic, 0x605, QMetaType::Void),
        // Signal 'lightProbeChanged'
        QtMocHelpers::SignalData<void()>(18, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'probeExposureChanged'
        QtMocHelpers::SignalData<void()>(19, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'probeHorizonChanged'
        QtMocHelpers::SignalData<void()>(20, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'probeOrientationChanged'
        QtMocHelpers::SignalData<void()>(21, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'depthTestEnabledChanged'
        QtMocHelpers::SignalData<void()>(22, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'depthPrePassEnabledChanged'
        QtMocHelpers::SignalData<void()>(23, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'tonemapModeChanged'
        QtMocHelpers::SignalData<void()>(24, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'skyboxBlurAmountChanged'
        QtMocHelpers::RevisionedSignalData<void()>(25, 4, QMC::AccessPublic, 0x604, QMetaType::Void),
        // Signal 'specularAAEnabledChanged'
        QtMocHelpers::RevisionedSignalData<void()>(26, 4, QMC::AccessPublic, 0x604, QMetaType::Void),
        // Signal 'lightmapperChanged'
        QtMocHelpers::RevisionedSignalData<void()>(27, 4, QMC::AccessPublic, 0x604, QMetaType::Void),
        // Signal 'skyBoxCubeMapChanged'
        QtMocHelpers::RevisionedSignalData<void()>(28, 4, QMC::AccessPublic, 0x604, QMetaType::Void),
        // Signal 'debugSettingsChanged'
        QtMocHelpers::RevisionedSignalData<void()>(29, 4, QMC::AccessPublic, 0x605, QMetaType::Void),
        // Signal 'scissorRectChanged'
        QtMocHelpers::RevisionedSignalData<void()>(30, 4, QMC::AccessPublic, 0x605, QMetaType::Void),
        // Signal 'fogChanged'
        QtMocHelpers::RevisionedSignalData<void()>(31, 4, QMC::AccessPublic, 0x605, QMetaType::Void),
        // Signal 'oitMethodChanged'
        QtMocHelpers::RevisionedSignalData<void()>(32, 4, QMC::AccessPublic, 0x609, QMetaType::Void),
        // Slot 'setAntialiasingMode'
        QtMocHelpers::SlotData<void(QQuick3DSceneEnvironment::QQuick3DEnvironmentAAModeValues)>(33, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 34, 35 },
        }}),
        // Slot 'setAntialiasingQuality'
        QtMocHelpers::SlotData<void(QQuick3DSceneEnvironment::QQuick3DEnvironmentAAQualityValues)>(36, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 37, 38 },
        }}),
        // Slot 'setTemporalAAMode'
        QtMocHelpers::RevisionedSlotData<void(const QQuick3DEnvironmentTemporalAAMode &)>(39, 4, QMC::AccessPublic, 0x60b, QMetaType::Void, {{
            { 0x80000000 | 40, 41 },
        }}),
        // Slot 'setTemporalAAEnabled'
        QtMocHelpers::SlotData<void(bool)>(42, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 43 },
        }}),
        // Slot 'setTemporalAAStrength'
        QtMocHelpers::SlotData<void(float)>(44, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 45 },
        }}),
        // Slot 'setBackgroundMode'
        QtMocHelpers::SlotData<void(QQuick3DSceneEnvironment::QQuick3DEnvironmentBackgroundTypes)>(46, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 47, 48 },
        }}),
        // Slot 'setClearColor'
        QtMocHelpers::SlotData<void(const QColor &)>(49, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 50, 51 },
        }}),
        // Slot 'setAoStrength'
        QtMocHelpers::SlotData<void(float)>(52, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 53 },
        }}),
        // Slot 'setAoDistance'
        QtMocHelpers::SlotData<void(float)>(54, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 55 },
        }}),
        // Slot 'setAoSoftness'
        QtMocHelpers::SlotData<void(float)>(56, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 57 },
        }}),
        // Slot 'setAoDither'
        QtMocHelpers::SlotData<void(bool)>(58, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 59 },
        }}),
        // Slot 'setAoSampleRate'
        QtMocHelpers::SlotData<void(int)>(60, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 61 },
        }}),
        // Slot 'setAoBias'
        QtMocHelpers::SlotData<void(float)>(62, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 63 },
        }}),
        // Slot 'setLightProbe'
        QtMocHelpers::SlotData<void(QQuick3DTexture *)>(64, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 65, 66 },
        }}),
        // Slot 'setProbeExposure'
        QtMocHelpers::SlotData<void(float)>(67, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 68 },
        }}),
        // Slot 'setProbeHorizon'
        QtMocHelpers::SlotData<void(float)>(69, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 70 },
        }}),
        // Slot 'setProbeOrientation'
        QtMocHelpers::SlotData<void(const QVector3D &)>(71, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 72, 73 },
        }}),
        // Slot 'setDepthTestEnabled'
        QtMocHelpers::SlotData<void(bool)>(74, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 75 },
        }}),
        // Slot 'setDepthPrePassEnabled'
        QtMocHelpers::SlotData<void(bool)>(76, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 77 },
        }}),
        // Slot 'setTonemapMode'
        QtMocHelpers::SlotData<void(QQuick3DSceneEnvironment::QQuick3DEnvironmentTonemapModes)>(78, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 79, 80 },
        }}),
        // Slot 'setSkyboxBlurAmount'
        QtMocHelpers::RevisionedSlotData<void(float)>(81, 4, QMC::AccessPublic, 0x604, QMetaType::Void, {{
            { QMetaType::Float, 82 },
        }}),
        // Slot 'setSpecularAAEnabled'
        QtMocHelpers::RevisionedSlotData<void(bool)>(83, 4, QMC::AccessPublic, 0x604, QMetaType::Void, {{
            { QMetaType::Bool, 84 },
        }}),
        // Slot 'setSkyBoxCubeMap'
        QtMocHelpers::RevisionedSlotData<void(QQuick3DCubeMapTexture *)>(85, 4, QMC::AccessPublic, 0x604, QMetaType::Void, {{
            { 0x80000000 | 86, 87 },
        }}),
        // Slot 'setLightmapper'
        QtMocHelpers::RevisionedSlotData<void(QQuick3DLightmapper *)>(88, 4, QMC::AccessPublic, 0x604, QMetaType::Void, {{
            { 0x80000000 | 89, 90 },
        }}),
        // Slot 'setDebugSettings'
        QtMocHelpers::RevisionedSlotData<void(QQuick3DDebugSettings *)>(91, 4, QMC::AccessPublic, 0x605, QMetaType::Void, {{
            { 0x80000000 | 92, 93 },
        }}),
        // Slot 'setScissorRect'
        QtMocHelpers::RevisionedSlotData<void(QRect)>(94, 4, QMC::AccessPublic, 0x605, QMetaType::Void, {{
            { 0x80000000 | 95, 96 },
        }}),
        // Slot 'setFog'
        QtMocHelpers::RevisionedSlotData<void(QQuick3DFog *)>(97, 4, QMC::AccessPublic, 0x605, QMetaType::Void, {{
            { 0x80000000 | 98, 99 },
        }}),
        // Slot 'setOitMethod'
        QtMocHelpers::RevisionedSlotData<void(QQuick3DSceneEnvironment::QQuick3DEnvironmentOITMethod)>(100, 4, QMC::AccessPublic, 0x609, QMetaType::Void, {{
            { 0x80000000 | 101, 102 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'antialiasingMode'
        QtMocHelpers::PropertyData<enum QQuick3DEnvironmentAAModeValues>(35, 0x80000000 | 103, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 0),
        // property 'antialiasingQuality'
        QtMocHelpers::PropertyData<enum QQuick3DEnvironmentAAQualityValues>(38, 0x80000000 | 104, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 1),
        // property 'temporalAAMode'
        QtMocHelpers::PropertyData<enum QQuick3DEnvironmentTemporalAAMode>(105, 0x80000000 | 40, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 2, 0x60b),
        // property 'temporalAAEnabled'
        QtMocHelpers::PropertyData<bool>(43, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 3),
        // property 'temporalAAStrength'
        QtMocHelpers::PropertyData<float>(106, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 4),
        // property 'backgroundMode'
        QtMocHelpers::PropertyData<enum QQuick3DEnvironmentBackgroundTypes>(48, 0x80000000 | 107, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 5),
        // property 'clearColor'
        QtMocHelpers::PropertyData<QColor>(51, 0x80000000 | 50, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 6),
        // property 'depthTestEnabled'
        QtMocHelpers::PropertyData<bool>(75, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 18),
        // property 'depthPrePassEnabled'
        QtMocHelpers::PropertyData<bool>(77, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 19),
        // property 'aoStrength'
        QtMocHelpers::PropertyData<float>(53, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 7),
        // property 'aoDistance'
        QtMocHelpers::PropertyData<float>(55, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 8),
        // property 'aoSoftness'
        QtMocHelpers::PropertyData<float>(57, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 9),
        // property 'aoDither'
        QtMocHelpers::PropertyData<bool>(59, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 10),
        // property 'aoSampleRate'
        QtMocHelpers::PropertyData<int>(61, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 11),
        // property 'aoBias'
        QtMocHelpers::PropertyData<float>(63, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 12),
        // property 'aoEnabled'
        QtMocHelpers::PropertyData<bool>(108, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 13, 0x605),
        // property 'lightProbe'
        QtMocHelpers::PropertyData<QQuick3DTexture*>(66, 0x80000000 | 65, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 14),
        // property 'probeExposure'
        QtMocHelpers::PropertyData<float>(68, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 15),
        // property 'probeHorizon'
        QtMocHelpers::PropertyData<float>(70, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'probeOrientation'
        QtMocHelpers::PropertyData<QVector3D>(109, 0x80000000 | 72, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 17),
        // property 'skyBoxCubeMap'
        QtMocHelpers::PropertyData<QQuick3DCubeMapTexture*>(110, 0x80000000 | 86, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 24, 0x604),
        // property 'tonemapMode'
        QtMocHelpers::PropertyData<enum QQuick3DEnvironmentTonemapModes>(80, 0x80000000 | 111, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 20),
        // property 'effects'
        QtMocHelpers::PropertyData<QQmlListProperty<QQuick3DEffect>>(112, 0x80000000 | 113, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'skyboxBlurAmount'
        QtMocHelpers::PropertyData<float>(114, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 21, 0x604),
        // property 'specularAAEnabled'
        QtMocHelpers::PropertyData<bool>(115, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 22, 0x604),
        // property 'lightmapper'
        QtMocHelpers::PropertyData<QQuick3DLightmapper*>(90, 0x80000000 | 89, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 23, 0x604),
        // property 'debugSettings'
        QtMocHelpers::PropertyData<QQuick3DDebugSettings*>(116, 0x80000000 | 92, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 25, 0x605),
        // property 'scissorRect'
        QtMocHelpers::PropertyData<QRect>(96, 0x80000000 | 95, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 26, 0x605),
        // property 'fog'
        QtMocHelpers::PropertyData<QQuick3DFog*>(99, 0x80000000 | 98, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 27, 0x605),
        // property 'oitMethod'
        QtMocHelpers::PropertyData<enum QQuick3DEnvironmentOITMethod>(117, 0x80000000 | 118, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 28, 0x609),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'QQuick3DEnvironmentAAModeValues'
        QtMocHelpers::EnumData<enum QQuick3DEnvironmentAAModeValues>(103, 103, QMC::EnumFlags{}).add({
            {  119, QQuick3DEnvironmentAAModeValues::NoAA },
            {  120, QQuick3DEnvironmentAAModeValues::SSAA },
            {  121, QQuick3DEnvironmentAAModeValues::MSAA },
            {  122, QQuick3DEnvironmentAAModeValues::ProgressiveAA },
        }),
        // enum 'QQuick3DEnvironmentAAQualityValues'
        QtMocHelpers::EnumData<enum QQuick3DEnvironmentAAQualityValues>(104, 104, QMC::EnumFlags{}).add({
            {  123, QQuick3DEnvironmentAAQualityValues::Medium },
            {  124, QQuick3DEnvironmentAAQualityValues::High },
            {  125, QQuick3DEnvironmentAAQualityValues::VeryHigh },
        }),
        // enum 'QQuick3DEnvironmentBackgroundTypes'
        QtMocHelpers::EnumData<enum QQuick3DEnvironmentBackgroundTypes>(107, 107, QMC::EnumFlags{}).add({
            {  126, QQuick3DEnvironmentBackgroundTypes::Transparent },
            {  127, QQuick3DEnvironmentBackgroundTypes::Unspecified },
            {  128, QQuick3DEnvironmentBackgroundTypes::Color },
            {  129, QQuick3DEnvironmentBackgroundTypes::SkyBox },
            {  130, QQuick3DEnvironmentBackgroundTypes::SkyBoxCubeMap },
        }),
        // enum 'QQuick3DEnvironmentTonemapModes'
        QtMocHelpers::EnumData<enum QQuick3DEnvironmentTonemapModes>(111, 111, QMC::EnumFlags{}).add({
            {  131, QQuick3DEnvironmentTonemapModes::TonemapModeNone },
            {  132, QQuick3DEnvironmentTonemapModes::TonemapModeLinear },
            {  133, QQuick3DEnvironmentTonemapModes::TonemapModeAces },
            {  134, QQuick3DEnvironmentTonemapModes::TonemapModeHejlDawson },
            {  135, QQuick3DEnvironmentTonemapModes::TonemapModeFilmic },
        }),
        // enum 'QQuick3DEnvironmentOITMethod'
        QtMocHelpers::EnumData<enum QQuick3DEnvironmentOITMethod>(118, 118, QMC::EnumFlags{}).add({
            {  136, QQuick3DEnvironmentOITMethod::OITNone },
            {  137, QQuick3DEnvironmentOITMethod::OITWeightedBlended },
            {  138, QQuick3DEnvironmentOITMethod::OITLinkedList },
        }),
        // enum 'QQuick3DEnvironmentTemporalAAMode'
        QtMocHelpers::EnumData<enum QQuick3DEnvironmentTemporalAAMode>(40, 40, QMC::EnumFlags{}).add({
            {  139, QQuick3DEnvironmentTemporalAAMode::TAADefault },
            {  140, QQuick3DEnvironmentTemporalAAMode::TAAMotionVector },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<QQuick3DSceneEnvironment, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QQuick3DSceneEnvironment::staticMetaObject = { {
    QMetaObject::SuperData::link<QQuick3DObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QQuick3DSceneEnvironmentE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QQuick3DSceneEnvironmentE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24QQuick3DSceneEnvironmentE_t>.metaTypes,
    nullptr
} };

void QQuick3DSceneEnvironment::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QQuick3DSceneEnvironment *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->antialiasingModeChanged(); break;
        case 1: _t->antialiasingQualityChanged(); break;
        case 2: _t->temporalAAModeChanged(); break;
        case 3: _t->temporalAAEnabledChanged(); break;
        case 4: _t->temporalAAStrengthChanged(); break;
        case 5: _t->backgroundModeChanged(); break;
        case 6: _t->clearColorChanged(); break;
        case 7: _t->aoStrengthChanged(); break;
        case 8: _t->aoDistanceChanged(); break;
        case 9: _t->aoSoftnessChanged(); break;
        case 10: _t->aoDitherChanged(); break;
        case 11: _t->aoSampleRateChanged(); break;
        case 12: _t->aoBiasChanged(); break;
        case 13: _t->aoEnabledChanged(); break;
        case 14: _t->lightProbeChanged(); break;
        case 15: _t->probeExposureChanged(); break;
        case 16: _t->probeHorizonChanged(); break;
        case 17: _t->probeOrientationChanged(); break;
        case 18: _t->depthTestEnabledChanged(); break;
        case 19: _t->depthPrePassEnabledChanged(); break;
        case 20: _t->tonemapModeChanged(); break;
        case 21: _t->skyboxBlurAmountChanged(); break;
        case 22: _t->specularAAEnabledChanged(); break;
        case 23: _t->lightmapperChanged(); break;
        case 24: _t->skyBoxCubeMapChanged(); break;
        case 25: _t->debugSettingsChanged(); break;
        case 26: _t->scissorRectChanged(); break;
        case 27: _t->fogChanged(); break;
        case 28: _t->oitMethodChanged(); break;
        case 29: _t->setAntialiasingMode((*reinterpret_cast<std::add_pointer_t<QQuick3DSceneEnvironment::QQuick3DEnvironmentAAModeValues>>(_a[1]))); break;
        case 30: _t->setAntialiasingQuality((*reinterpret_cast<std::add_pointer_t<QQuick3DSceneEnvironment::QQuick3DEnvironmentAAQualityValues>>(_a[1]))); break;
        case 31: _t->setTemporalAAMode((*reinterpret_cast<std::add_pointer_t<enum QQuick3DEnvironmentTemporalAAMode>>(_a[1]))); break;
        case 32: _t->setTemporalAAEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 33: _t->setTemporalAAStrength((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 34: _t->setBackgroundMode((*reinterpret_cast<std::add_pointer_t<QQuick3DSceneEnvironment::QQuick3DEnvironmentBackgroundTypes>>(_a[1]))); break;
        case 35: _t->setClearColor((*reinterpret_cast<std::add_pointer_t<QColor>>(_a[1]))); break;
        case 36: _t->setAoStrength((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 37: _t->setAoDistance((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 38: _t->setAoSoftness((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 39: _t->setAoDither((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 40: _t->setAoSampleRate((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 41: _t->setAoBias((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 42: _t->setLightProbe((*reinterpret_cast<std::add_pointer_t<QQuick3DTexture*>>(_a[1]))); break;
        case 43: _t->setProbeExposure((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 44: _t->setProbeHorizon((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 45: _t->setProbeOrientation((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1]))); break;
        case 46: _t->setDepthTestEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 47: _t->setDepthPrePassEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 48: _t->setTonemapMode((*reinterpret_cast<std::add_pointer_t<QQuick3DSceneEnvironment::QQuick3DEnvironmentTonemapModes>>(_a[1]))); break;
        case 49: _t->setSkyboxBlurAmount((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 50: _t->setSpecularAAEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 51: _t->setSkyBoxCubeMap((*reinterpret_cast<std::add_pointer_t<QQuick3DCubeMapTexture*>>(_a[1]))); break;
        case 52: _t->setLightmapper((*reinterpret_cast<std::add_pointer_t<QQuick3DLightmapper*>>(_a[1]))); break;
        case 53: _t->setDebugSettings((*reinterpret_cast<std::add_pointer_t<QQuick3DDebugSettings*>>(_a[1]))); break;
        case 54: _t->setScissorRect((*reinterpret_cast<std::add_pointer_t<QRect>>(_a[1]))); break;
        case 55: _t->setFog((*reinterpret_cast<std::add_pointer_t<QQuick3DFog*>>(_a[1]))); break;
        case 56: _t->setOitMethod((*reinterpret_cast<std::add_pointer_t<QQuick3DSceneEnvironment::QQuick3DEnvironmentOITMethod>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 42:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QQuick3DTexture* >(); break;
            }
            break;
        case 52:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QQuick3DLightmapper* >(); break;
            }
            break;
        case 53:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QQuick3DDebugSettings* >(); break;
            }
            break;
        case 55:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QQuick3DFog* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::antialiasingModeChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::antialiasingQualityChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::temporalAAModeChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::temporalAAEnabledChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::temporalAAStrengthChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::backgroundModeChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::clearColorChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::aoStrengthChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::aoDistanceChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::aoSoftnessChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::aoDitherChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::aoSampleRateChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::aoBiasChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::aoEnabledChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::lightProbeChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::probeExposureChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::probeHorizonChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::probeOrientationChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::depthTestEnabledChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::depthPrePassEnabledChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::tonemapModeChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::skyboxBlurAmountChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::specularAAEnabledChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::lightmapperChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::skyBoxCubeMapChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::debugSettingsChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::scissorRectChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::fogChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (QQuick3DSceneEnvironment::*)()>(_a, &QQuick3DSceneEnvironment::oitMethodChanged, 28))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 26:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QQuick3DDebugSettings* >(); break;
        case 28:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QQuick3DFog* >(); break;
        case 25:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QQuick3DLightmapper* >(); break;
        case 16:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QQuick3DTexture* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<enum QQuick3DEnvironmentAAModeValues*>(_v) = _t->antialiasingMode(); break;
        case 1: *reinterpret_cast<enum QQuick3DEnvironmentAAQualityValues*>(_v) = _t->antialiasingQuality(); break;
        case 2: *reinterpret_cast<enum QQuick3DEnvironmentTemporalAAMode*>(_v) = _t->temporalAAMode(); break;
        case 3: *reinterpret_cast<bool*>(_v) = _t->temporalAAEnabled(); break;
        case 4: *reinterpret_cast<float*>(_v) = _t->temporalAAStrength(); break;
        case 5: *reinterpret_cast<enum QQuick3DEnvironmentBackgroundTypes*>(_v) = _t->backgroundMode(); break;
        case 6: *reinterpret_cast<QColor*>(_v) = _t->clearColor(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->depthTestEnabled(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->depthPrePassEnabled(); break;
        case 9: *reinterpret_cast<float*>(_v) = _t->aoStrength(); break;
        case 10: *reinterpret_cast<float*>(_v) = _t->aoDistance(); break;
        case 11: *reinterpret_cast<float*>(_v) = _t->aoSoftness(); break;
        case 12: *reinterpret_cast<bool*>(_v) = _t->aoDither(); break;
        case 13: *reinterpret_cast<int*>(_v) = _t->aoSampleRate(); break;
        case 14: *reinterpret_cast<float*>(_v) = _t->aoBias(); break;
        case 15: *reinterpret_cast<bool*>(_v) = _t->aoEnabled(); break;
        case 16: *reinterpret_cast<QQuick3DTexture**>(_v) = _t->lightProbe(); break;
        case 17: *reinterpret_cast<float*>(_v) = _t->probeExposure(); break;
        case 18: *reinterpret_cast<float*>(_v) = _t->probeHorizon(); break;
        case 19: *reinterpret_cast<QVector3D*>(_v) = _t->probeOrientation(); break;
        case 20: *reinterpret_cast<QQuick3DCubeMapTexture**>(_v) = _t->skyBoxCubeMap(); break;
        case 21: *reinterpret_cast<enum QQuick3DEnvironmentTonemapModes*>(_v) = _t->tonemapMode(); break;
        case 22: *reinterpret_cast<QQmlListProperty<QQuick3DEffect>*>(_v) = _t->effects(); break;
        case 23: *reinterpret_cast<float*>(_v) = _t->skyboxBlurAmount(); break;
        case 24: *reinterpret_cast<bool*>(_v) = _t->specularAAEnabled(); break;
        case 25: *reinterpret_cast<QQuick3DLightmapper**>(_v) = _t->lightmapper(); break;
        case 26: *reinterpret_cast<QQuick3DDebugSettings**>(_v) = _t->debugSettings(); break;
        case 27: *reinterpret_cast<QRect*>(_v) = _t->scissorRect(); break;
        case 28: *reinterpret_cast<QQuick3DFog**>(_v) = _t->fog(); break;
        case 29: *reinterpret_cast<enum QQuick3DEnvironmentOITMethod*>(_v) = _t->oitMethod(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setAntialiasingMode(*reinterpret_cast<enum QQuick3DEnvironmentAAModeValues*>(_v)); break;
        case 1: _t->setAntialiasingQuality(*reinterpret_cast<enum QQuick3DEnvironmentAAQualityValues*>(_v)); break;
        case 2: _t->setTemporalAAMode(*reinterpret_cast<enum QQuick3DEnvironmentTemporalAAMode*>(_v)); break;
        case 3: _t->setTemporalAAEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 4: _t->setTemporalAAStrength(*reinterpret_cast<float*>(_v)); break;
        case 5: _t->setBackgroundMode(*reinterpret_cast<enum QQuick3DEnvironmentBackgroundTypes*>(_v)); break;
        case 6: _t->setClearColor(*reinterpret_cast<QColor*>(_v)); break;
        case 7: _t->setDepthTestEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 8: _t->setDepthPrePassEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 9: _t->setAoStrength(*reinterpret_cast<float*>(_v)); break;
        case 10: _t->setAoDistance(*reinterpret_cast<float*>(_v)); break;
        case 11: _t->setAoSoftness(*reinterpret_cast<float*>(_v)); break;
        case 12: _t->setAoDither(*reinterpret_cast<bool*>(_v)); break;
        case 13: _t->setAoSampleRate(*reinterpret_cast<int*>(_v)); break;
        case 14: _t->setAoBias(*reinterpret_cast<float*>(_v)); break;
        case 15: _t->setAoEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 16: _t->setLightProbe(*reinterpret_cast<QQuick3DTexture**>(_v)); break;
        case 17: _t->setProbeExposure(*reinterpret_cast<float*>(_v)); break;
        case 18: _t->setProbeHorizon(*reinterpret_cast<float*>(_v)); break;
        case 19: _t->setProbeOrientation(*reinterpret_cast<QVector3D*>(_v)); break;
        case 20: _t->setSkyBoxCubeMap(*reinterpret_cast<QQuick3DCubeMapTexture**>(_v)); break;
        case 21: _t->setTonemapMode(*reinterpret_cast<enum QQuick3DEnvironmentTonemapModes*>(_v)); break;
        case 23: _t->setSkyboxBlurAmount(*reinterpret_cast<float*>(_v)); break;
        case 24: _t->setSpecularAAEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 25: _t->setLightmapper(*reinterpret_cast<QQuick3DLightmapper**>(_v)); break;
        case 26: _t->setDebugSettings(*reinterpret_cast<QQuick3DDebugSettings**>(_v)); break;
        case 27: _t->setScissorRect(*reinterpret_cast<QRect*>(_v)); break;
        case 28: _t->setFog(*reinterpret_cast<QQuick3DFog**>(_v)); break;
        case 29: _t->setOitMethod(*reinterpret_cast<enum QQuick3DEnvironmentOITMethod*>(_v)); break;
        default: break;
        }
    }
}

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

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

int QQuick3DSceneEnvironment::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QQuick3DObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 57)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 57;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 57)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 57;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 30;
    }
    return _id;
}

// SIGNAL 0
void QQuick3DSceneEnvironment::antialiasingModeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void QQuick3DSceneEnvironment::antialiasingQualityChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void QQuick3DSceneEnvironment::temporalAAModeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

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

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

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

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

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

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

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

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

// SIGNAL 11
void QQuick3DSceneEnvironment::aoSampleRateChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 11, nullptr);
}

// SIGNAL 12
void QQuick3DSceneEnvironment::aoBiasChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
}

// SIGNAL 13
void QQuick3DSceneEnvironment::aoEnabledChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}

// SIGNAL 14
void QQuick3DSceneEnvironment::lightProbeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 14, nullptr);
}

// SIGNAL 15
void QQuick3DSceneEnvironment::probeExposureChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
}

// SIGNAL 16
void QQuick3DSceneEnvironment::probeHorizonChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

// SIGNAL 17
void QQuick3DSceneEnvironment::probeOrientationChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
}

// SIGNAL 18
void QQuick3DSceneEnvironment::depthTestEnabledChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 18, nullptr);
}

// SIGNAL 19
void QQuick3DSceneEnvironment::depthPrePassEnabledChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 19, nullptr);
}

// SIGNAL 20
void QQuick3DSceneEnvironment::tonemapModeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 20, nullptr);
}

// SIGNAL 21
void QQuick3DSceneEnvironment::skyboxBlurAmountChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 21, nullptr);
}

// SIGNAL 22
void QQuick3DSceneEnvironment::specularAAEnabledChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 22, nullptr);
}

// SIGNAL 23
void QQuick3DSceneEnvironment::lightmapperChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 23, nullptr);
}

// SIGNAL 24
void QQuick3DSceneEnvironment::skyBoxCubeMapChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 24, nullptr);
}

// SIGNAL 25
void QQuick3DSceneEnvironment::debugSettingsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 25, nullptr);
}

// SIGNAL 26
void QQuick3DSceneEnvironment::scissorRectChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 26, nullptr);
}

// SIGNAL 27
void QQuick3DSceneEnvironment::fogChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 27, nullptr);
}

// SIGNAL 28
void QQuick3DSceneEnvironment::oitMethodChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 28, nullptr);
}
QT_WARNING_POP
