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

#include "../../../../../../stellarium/plugins/Scenery3d/src/Scenery3d.hpp"
#include <QtCore/qmetatype.h>
#include <QtCore/qplugin.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'Scenery3d.hpp' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.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_ZN9Scenery3dE_t {};
} // unnamed namespace

template <> constexpr inline auto Scenery3d::qt_create_metaobjectdata<qt_meta_tag_ZN9Scenery3dE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Scenery3d",
        "enableSceneChanged",
        "",
        "val",
        "enablePixelLightingChanged",
        "enableShadowsChanged",
        "useSimpleShadowsChanged",
        "enableBumpsChanged",
        "shadowFilterQualityChanged",
        "S3DEnum::ShadowFilterQuality",
        "enablePCSSChanged",
        "cubemappingModeChanged",
        "S3DEnum::CubemappingMode",
        "useFullCubemapShadowsChanged",
        "enableDebugInfoChanged",
        "enableLocationInfoChanged",
        "locationInfoStyleChanged",
        "S3DRenderer::LocationInfoStyle",
        "style",
        "forceHorizonPolylineChanged",
        "enableTorchLightChanged",
        "torchStrengthChanged",
        "torchRangeChanged",
        "directionalLightPushChanged",
        "ignoreInitialViewChanged",
        "ignore",
        "enableLazyDrawingChanged",
        "lazyDrawingIntervalChanged",
        "onlyDominantFaceWhenMovingChanged",
        "secondDominantFaceWhenMovingChanged",
        "cubemapSizeChanged",
        "shadowmapSizeChanged",
        "currentSceneChanged",
        "SceneInfo",
        "sceneInfo",
        "currentSceneIDChanged",
        "sceneID",
        "loadingSceneIDChanged",
        "progressReport",
        "str",
        "min",
        "max",
        "relativeMove",
        "Vec3d",
        "move",
        "reloadShaders",
        "showMessage",
        "message",
        "showStoredViewDialog",
        "setEnableScene",
        "getEnableScene",
        "setEnablePixelLighting",
        "getEnablePixelLighting",
        "setEnableShadows",
        "enableShadows",
        "getEnableShadows",
        "setUseSimpleShadows",
        "simpleShadows",
        "getUseSimpleShadows",
        "setEnableBumps",
        "enableBumps",
        "getEnableBumps",
        "getShadowFilterQuality",
        "setShadowFilterQuality",
        "setEnablePCSS",
        "getEnablePCSS",
        "getCubemappingMode",
        "setCubemappingMode",
        "getUseFullCubemapShadows",
        "setUseFullCubemapShadows",
        "useFullCubemapShadows",
        "setEnableDebugInfo",
        "debugEnabled",
        "getEnableDebugInfo",
        "setEnableLocationInfo",
        "enableLocationInfo",
        "getEnableLocationInfo",
        "setLocationInfoStyle",
        "getLocationInfoStyle",
        "setForceHorizonPolyline",
        "forcePolyline",
        "getForceHorizonPolyline",
        "setEnableTorchLight",
        "enableTorchLight",
        "getEnableTorchLight",
        "setTorchStrength",
        "torchStrength",
        "getTorchStrength",
        "setTorchRange",
        "torchRange",
        "getTorchRange",
        "setDirectionalLightPush",
        "push",
        "getDirectionalLightPush",
        "setIgnoreInitialView",
        "getIgnoreInitialView",
        "setEnableLazyDrawing",
        "getEnableLazyDrawing",
        "setOnlyDominantFaceWhenMoving",
        "getOnlyDominantFaceWhenMoving",
        "setSecondDominantFaceWhenMoving",
        "getSecondDominantFaceWhenMoving",
        "forceCubemapRedraw",
        "setLazyDrawingInterval",
        "getLazyDrawingInterval",
        "setCubemapSize",
        "getCubemapSize",
        "setShadowmapSize",
        "getShadowmapSize",
        "getIsGeometryShaderSupported",
        "getAreShadowsSupported",
        "getIsShadowFilteringSupported",
        "getIsANGLE",
        "getMaximumFramebufferSize",
        "getCurrentScene",
        "getCurrentSceneID",
        "getLoadingSceneID",
        "getLoadingScene",
        "loadScenery3dByName",
        "name",
        "loadScenery3dByID",
        "id",
        "getDefaultScenery3dID",
        "setDefaultScenery3dID",
        "setView",
        "StoredView",
        "view",
        "setDate",
        "getCurrentView",
        "clearMessage",
        "loadSceneCompleted",
        "progressReceive",
        "loadScene",
        "scene",
        "enableScene",
        "enablePixelLighting",
        "useSimpleShadows",
        "shadowFilterQuality",
        "enablePCSS",
        "cubemappingMode",
        "enableDebugInfo",
        "locationInfoStyle",
        "forceHorizonPolyline",
        "directionalLightPush",
        "ignoreInitialView",
        "enableLazyDrawing",
        "lazyDrawingInterval",
        "onlyDominantFaceWhenMoving",
        "secondDominantFaceWhenMoving",
        "cubemapSize",
        "shadowmapSize",
        "currentSceneID",
        "loadingSceneID",
        "isGeometryShaderSupported",
        "areShadowsSupported",
        "isShadowFilteringSupported",
        "isANGLE",
        "maximumFramebufferSize"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'enableSceneChanged'
        QtMocHelpers::SignalData<void(const bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'enablePixelLightingChanged'
        QtMocHelpers::SignalData<void(const bool)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'enableShadowsChanged'
        QtMocHelpers::SignalData<void(const bool)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'useSimpleShadowsChanged'
        QtMocHelpers::SignalData<void(const bool)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'enableBumpsChanged'
        QtMocHelpers::SignalData<void(const bool)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'shadowFilterQualityChanged'
        QtMocHelpers::SignalData<void(const S3DEnum::ShadowFilterQuality)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 3 },
        }}),
        // Signal 'enablePCSSChanged'
        QtMocHelpers::SignalData<void(const bool)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'cubemappingModeChanged'
        QtMocHelpers::SignalData<void(const S3DEnum::CubemappingMode)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 12, 3 },
        }}),
        // Signal 'useFullCubemapShadowsChanged'
        QtMocHelpers::SignalData<void(const bool)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'enableDebugInfoChanged'
        QtMocHelpers::SignalData<void(const bool)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'enableLocationInfoChanged'
        QtMocHelpers::SignalData<void(const bool)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'locationInfoStyleChanged'
        QtMocHelpers::SignalData<void(S3DRenderer::LocationInfoStyle)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 17, 18 },
        }}),
        // Signal 'forceHorizonPolylineChanged'
        QtMocHelpers::SignalData<void(const bool)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'enableTorchLightChanged'
        QtMocHelpers::SignalData<void(const bool)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'torchStrengthChanged'
        QtMocHelpers::SignalData<void(const float)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 3 },
        }}),
        // Signal 'torchRangeChanged'
        QtMocHelpers::SignalData<void(const float)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 3 },
        }}),
        // Signal 'directionalLightPushChanged'
        QtMocHelpers::SignalData<void(const float)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 3 },
        }}),
        // Signal 'ignoreInitialViewChanged'
        QtMocHelpers::SignalData<void(const bool)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 25 },
        }}),
        // Signal 'enableLazyDrawingChanged'
        QtMocHelpers::SignalData<void(const bool)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'lazyDrawingIntervalChanged'
        QtMocHelpers::SignalData<void(const double)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 3 },
        }}),
        // Signal 'onlyDominantFaceWhenMovingChanged'
        QtMocHelpers::SignalData<void(const bool)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'secondDominantFaceWhenMovingChanged'
        QtMocHelpers::SignalData<void(const bool)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'cubemapSizeChanged'
        QtMocHelpers::SignalData<void(const uint)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 3 },
        }}),
        // Signal 'shadowmapSizeChanged'
        QtMocHelpers::SignalData<void(const uint)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 3 },
        }}),
        // Signal 'currentSceneChanged'
        QtMocHelpers::SignalData<void(const SceneInfo &)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 33, 34 },
        }}),
        // Signal 'currentSceneIDChanged'
        QtMocHelpers::SignalData<void(const QString &)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 36 },
        }}),
        // Signal 'loadingSceneIDChanged'
        QtMocHelpers::SignalData<void(const QString &)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 36 },
        }}),
        // Signal 'progressReport'
        QtMocHelpers::SignalData<void(const QString &, int, int, int) const>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 }, { QMetaType::Int, 3 }, { QMetaType::Int, 40 }, { QMetaType::Int, 41 },
        }}),
        // Slot 'relativeMove'
        QtMocHelpers::SlotData<void(const Vec3d &)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 43, 44 },
        }}),
        // Slot 'reloadShaders'
        QtMocHelpers::SlotData<void()>(45, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'showMessage'
        QtMocHelpers::SlotData<void(const QString &)>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 47 },
        }}),
        // Slot 'showStoredViewDialog'
        QtMocHelpers::SlotData<void()>(48, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setEnableScene'
        QtMocHelpers::SlotData<void(const bool)>(49, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getEnableScene'
        QtMocHelpers::SlotData<bool() const>(50, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setEnablePixelLighting'
        QtMocHelpers::SlotData<void(const bool)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getEnablePixelLighting'
        QtMocHelpers::SlotData<bool() const>(52, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setEnableShadows'
        QtMocHelpers::SlotData<void(const bool)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 54 },
        }}),
        // Slot 'getEnableShadows'
        QtMocHelpers::SlotData<bool() const>(55, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setUseSimpleShadows'
        QtMocHelpers::SlotData<void(const bool)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 57 },
        }}),
        // Slot 'getUseSimpleShadows'
        QtMocHelpers::SlotData<bool() const>(58, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setEnableBumps'
        QtMocHelpers::SlotData<void(const bool)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 60 },
        }}),
        // Slot 'getEnableBumps'
        QtMocHelpers::SlotData<bool() const>(61, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getShadowFilterQuality'
        QtMocHelpers::SlotData<S3DEnum::ShadowFilterQuality() const>(62, 2, QMC::AccessPublic, 0x80000000 | 9),
        // Slot 'setShadowFilterQuality'
        QtMocHelpers::SlotData<void(const S3DEnum::ShadowFilterQuality)>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 3 },
        }}),
        // Slot 'setEnablePCSS'
        QtMocHelpers::SlotData<void(const bool)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getEnablePCSS'
        QtMocHelpers::SlotData<bool() const>(65, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getCubemappingMode'
        QtMocHelpers::SlotData<S3DEnum::CubemappingMode() const>(66, 2, QMC::AccessPublic, 0x80000000 | 12),
        // Slot 'setCubemappingMode'
        QtMocHelpers::SlotData<void(const S3DEnum::CubemappingMode)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 12, 3 },
        }}),
        // Slot 'getUseFullCubemapShadows'
        QtMocHelpers::SlotData<bool() const>(68, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setUseFullCubemapShadows'
        QtMocHelpers::SlotData<void(const bool)>(69, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 70 },
        }}),
        // Slot 'setEnableDebugInfo'
        QtMocHelpers::SlotData<void(const bool)>(71, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 72 },
        }}),
        // Slot 'getEnableDebugInfo'
        QtMocHelpers::SlotData<bool() const>(73, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setEnableLocationInfo'
        QtMocHelpers::SlotData<void(const bool)>(74, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 75 },
        }}),
        // Slot 'getEnableLocationInfo'
        QtMocHelpers::SlotData<bool() const>(76, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setLocationInfoStyle'
        QtMocHelpers::SlotData<void(const S3DRenderer::LocationInfoStyle)>(77, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 17, 18 },
        }}),
        // Slot 'getLocationInfoStyle'
        QtMocHelpers::SlotData<S3DRenderer::LocationInfoStyle() const>(78, 2, QMC::AccessPublic, 0x80000000 | 17),
        // Slot 'setForceHorizonPolyline'
        QtMocHelpers::SlotData<void(const bool)>(79, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 80 },
        }}),
        // Slot 'getForceHorizonPolyline'
        QtMocHelpers::SlotData<bool() const>(81, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setEnableTorchLight'
        QtMocHelpers::SlotData<void(const bool)>(82, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 83 },
        }}),
        // Slot 'getEnableTorchLight'
        QtMocHelpers::SlotData<bool() const>(84, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setTorchStrength'
        QtMocHelpers::SlotData<void(const float)>(85, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 86 },
        }}),
        // Slot 'getTorchStrength'
        QtMocHelpers::SlotData<float() const>(87, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setTorchRange'
        QtMocHelpers::SlotData<void(const float)>(88, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 89 },
        }}),
        // Slot 'getTorchRange'
        QtMocHelpers::SlotData<float() const>(90, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setDirectionalLightPush'
        QtMocHelpers::SlotData<void(const float)>(91, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 92 },
        }}),
        // Slot 'getDirectionalLightPush'
        QtMocHelpers::SlotData<float() const>(93, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setIgnoreInitialView'
        QtMocHelpers::SlotData<void(const bool)>(94, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 25 },
        }}),
        // Slot 'getIgnoreInitialView'
        QtMocHelpers::SlotData<bool() const>(95, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setEnableLazyDrawing'
        QtMocHelpers::SlotData<void(const bool)>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getEnableLazyDrawing'
        QtMocHelpers::SlotData<bool() const>(97, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setOnlyDominantFaceWhenMoving'
        QtMocHelpers::SlotData<void(const bool)>(98, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getOnlyDominantFaceWhenMoving'
        QtMocHelpers::SlotData<bool() const>(99, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setSecondDominantFaceWhenMoving'
        QtMocHelpers::SlotData<void(const bool)>(100, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getSecondDominantFaceWhenMoving'
        QtMocHelpers::SlotData<bool() const>(101, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'forceCubemapRedraw'
        QtMocHelpers::SlotData<void()>(102, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setLazyDrawingInterval'
        QtMocHelpers::SlotData<void(const double)>(103, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 3 },
        }}),
        // Slot 'getLazyDrawingInterval'
        QtMocHelpers::SlotData<double() const>(104, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setCubemapSize'
        QtMocHelpers::SlotData<void(const uint)>(105, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 3 },
        }}),
        // Slot 'getCubemapSize'
        QtMocHelpers::SlotData<uint() const>(106, 2, QMC::AccessPublic, QMetaType::UInt),
        // Slot 'setShadowmapSize'
        QtMocHelpers::SlotData<void(const uint)>(107, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 3 },
        }}),
        // Slot 'getShadowmapSize'
        QtMocHelpers::SlotData<uint() const>(108, 2, QMC::AccessPublic, QMetaType::UInt),
        // Slot 'getIsGeometryShaderSupported'
        QtMocHelpers::SlotData<bool() const>(109, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getAreShadowsSupported'
        QtMocHelpers::SlotData<bool() const>(110, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getIsShadowFilteringSupported'
        QtMocHelpers::SlotData<bool() const>(111, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getIsANGLE'
        QtMocHelpers::SlotData<bool() const>(112, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getMaximumFramebufferSize'
        QtMocHelpers::SlotData<uint() const>(113, 2, QMC::AccessPublic, QMetaType::UInt),
        // Slot 'getCurrentScene'
        QtMocHelpers::SlotData<SceneInfo() const>(114, 2, QMC::AccessPublic, 0x80000000 | 33),
        // Slot 'getCurrentSceneID'
        QtMocHelpers::SlotData<QString() const>(115, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getLoadingSceneID'
        QtMocHelpers::SlotData<QString() const>(116, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getLoadingScene'
        QtMocHelpers::SlotData<SceneInfo() const>(117, 2, QMC::AccessPublic, 0x80000000 | 33),
        // Slot 'loadScenery3dByName'
        QtMocHelpers::SlotData<SceneInfo(const QString &)>(118, 2, QMC::AccessPublic, 0x80000000 | 33, {{
            { QMetaType::QString, 119 },
        }}),
        // Slot 'loadScenery3dByID'
        QtMocHelpers::SlotData<SceneInfo(const QString &)>(120, 2, QMC::AccessPublic, 0x80000000 | 33, {{
            { QMetaType::QString, 121 },
        }}),
        // Slot 'getDefaultScenery3dID'
        QtMocHelpers::SlotData<QString() const>(122, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'setDefaultScenery3dID'
        QtMocHelpers::SlotData<void(const QString &)>(123, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 121 },
        }}),
        // Slot 'setView'
        QtMocHelpers::SlotData<void(const StoredView &, const bool)>(124, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 125, 126 }, { QMetaType::Bool, 127 },
        }}),
        // Slot 'getCurrentView'
        QtMocHelpers::SlotData<StoredView() const>(128, 2, QMC::AccessPublic, 0x80000000 | 125),
        // Slot 'clearMessage'
        QtMocHelpers::SlotData<void()>(129, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'loadSceneCompleted'
        QtMocHelpers::SlotData<void()>(130, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'progressReceive'
        QtMocHelpers::SlotData<void(const QString &, int, int, int)>(131, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 39 }, { QMetaType::Int, 3 }, { QMetaType::Int, 40 }, { QMetaType::Int, 41 },
        }}),
        // Slot 'loadScene'
        QtMocHelpers::SlotData<void(const SceneInfo &)>(132, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 33, 133 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'enableScene'
        QtMocHelpers::PropertyData<bool>(134, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
        // property 'enablePixelLighting'
        QtMocHelpers::PropertyData<bool>(135, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'enableShadows'
        QtMocHelpers::PropertyData<bool>(54, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'useSimpleShadows'
        QtMocHelpers::PropertyData<bool>(136, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 3),
        // property 'enableBumps'
        QtMocHelpers::PropertyData<bool>(60, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 4),
        // property 'shadowFilterQuality'
        QtMocHelpers::PropertyData<S3DEnum::ShadowFilterQuality>(137, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 5),
        // property 'enablePCSS'
        QtMocHelpers::PropertyData<bool>(138, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 6),
        // property 'cubemappingMode'
        QtMocHelpers::PropertyData<S3DEnum::CubemappingMode>(139, 0x80000000 | 12, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 7),
        // property 'useFullCubemapShadows'
        QtMocHelpers::PropertyData<bool>(70, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 8),
        // property 'enableDebugInfo'
        QtMocHelpers::PropertyData<bool>(140, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 9),
        // property 'enableLocationInfo'
        QtMocHelpers::PropertyData<bool>(75, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 10),
        // property 'locationInfoStyle'
        QtMocHelpers::PropertyData<S3DRenderer::LocationInfoStyle>(141, 0x80000000 | 17, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 11),
        // property 'forceHorizonPolyline'
        QtMocHelpers::PropertyData<bool>(142, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 12),
        // property 'enableTorchLight'
        QtMocHelpers::PropertyData<bool>(83, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 13),
        // property 'torchStrength'
        QtMocHelpers::PropertyData<float>(86, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 14),
        // property 'torchRange'
        QtMocHelpers::PropertyData<float>(89, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 15),
        // property 'directionalLightPush'
        QtMocHelpers::PropertyData<float>(143, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'ignoreInitialView'
        QtMocHelpers::PropertyData<bool>(144, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 17),
        // property 'enableLazyDrawing'
        QtMocHelpers::PropertyData<bool>(145, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 18),
        // property 'lazyDrawingInterval'
        QtMocHelpers::PropertyData<double>(146, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 19),
        // property 'onlyDominantFaceWhenMoving'
        QtMocHelpers::PropertyData<bool>(147, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 20),
        // property 'secondDominantFaceWhenMoving'
        QtMocHelpers::PropertyData<bool>(148, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 21),
        // property 'cubemapSize'
        QtMocHelpers::PropertyData<uint>(149, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 22),
        // property 'shadowmapSize'
        QtMocHelpers::PropertyData<uint>(150, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 23),
        // property 'currentSceneID'
        QtMocHelpers::PropertyData<QString>(151, QMetaType::QString, QMC::Readable | QMC::Designable | QMC::Scriptable, 25),
        // property 'loadingSceneID'
        QtMocHelpers::PropertyData<QString>(152, QMetaType::QString, QMC::Readable | QMC::Designable | QMC::Scriptable, 26),
        // property 'isGeometryShaderSupported'
        QtMocHelpers::PropertyData<bool>(153, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'areShadowsSupported'
        QtMocHelpers::PropertyData<bool>(154, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'isShadowFilteringSupported'
        QtMocHelpers::PropertyData<bool>(155, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'isANGLE'
        QtMocHelpers::PropertyData<bool>(156, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'maximumFramebufferSize'
        QtMocHelpers::PropertyData<uint>(157, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Scenery3d, qt_meta_tag_ZN9Scenery3dE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN9Scenery3dE[] = {
    QMetaObject::SuperData::link<S3DEnum::staticMetaObject>(),
    QMetaObject::SuperData::link<S3DRenderer::staticMetaObject>(),
    nullptr
};

Q_CONSTINIT const QMetaObject Scenery3d::staticMetaObject = { {
    QMetaObject::SuperData::link<StelModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9Scenery3dE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9Scenery3dE_t>.data,
    qt_static_metacall,
    qt_meta_extradata_ZN9Scenery3dE,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN9Scenery3dE_t>.metaTypes,
    nullptr
} };

void Scenery3d::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Scenery3d *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->enableSceneChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 1: _t->enablePixelLightingChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 2: _t->enableShadowsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 3: _t->useSimpleShadowsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 4: _t->enableBumpsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 5: _t->shadowFilterQualityChanged((*reinterpret_cast<std::add_pointer_t<S3DEnum::ShadowFilterQuality>>(_a[1]))); break;
        case 6: _t->enablePCSSChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->cubemappingModeChanged((*reinterpret_cast<std::add_pointer_t<S3DEnum::CubemappingMode>>(_a[1]))); break;
        case 8: _t->useFullCubemapShadowsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: _t->enableDebugInfoChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 10: _t->enableLocationInfoChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 11: _t->locationInfoStyleChanged((*reinterpret_cast<std::add_pointer_t<S3DRenderer::LocationInfoStyle>>(_a[1]))); break;
        case 12: _t->forceHorizonPolylineChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 13: _t->enableTorchLightChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 14: _t->torchStrengthChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 15: _t->torchRangeChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 16: _t->directionalLightPushChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 17: _t->ignoreInitialViewChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 18: _t->enableLazyDrawingChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 19: _t->lazyDrawingIntervalChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 20: _t->onlyDominantFaceWhenMovingChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 21: _t->secondDominantFaceWhenMovingChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 22: _t->cubemapSizeChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 23: _t->shadowmapSizeChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 24: _t->currentSceneChanged((*reinterpret_cast<std::add_pointer_t<SceneInfo>>(_a[1]))); break;
        case 25: _t->currentSceneIDChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 26: _t->loadingSceneIDChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 27: _t->progressReport((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 28: _t->relativeMove((*reinterpret_cast<std::add_pointer_t<Vec3d>>(_a[1]))); break;
        case 29: _t->reloadShaders(); break;
        case 30: _t->showMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 31: _t->showStoredViewDialog(); break;
        case 32: _t->setEnableScene((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 33: { bool _r = _t->getEnableScene();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 34: _t->setEnablePixelLighting((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 35: { bool _r = _t->getEnablePixelLighting();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 36: _t->setEnableShadows((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 37: { bool _r = _t->getEnableShadows();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 38: _t->setUseSimpleShadows((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 39: { bool _r = _t->getUseSimpleShadows();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 40: _t->setEnableBumps((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 41: { bool _r = _t->getEnableBumps();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 42: { S3DEnum::ShadowFilterQuality _r = _t->getShadowFilterQuality();
            if (_a[0]) *reinterpret_cast<S3DEnum::ShadowFilterQuality*>(_a[0]) = std::move(_r); }  break;
        case 43: _t->setShadowFilterQuality((*reinterpret_cast<std::add_pointer_t<S3DEnum::ShadowFilterQuality>>(_a[1]))); break;
        case 44: _t->setEnablePCSS((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 45: { bool _r = _t->getEnablePCSS();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 46: { S3DEnum::CubemappingMode _r = _t->getCubemappingMode();
            if (_a[0]) *reinterpret_cast<S3DEnum::CubemappingMode*>(_a[0]) = std::move(_r); }  break;
        case 47: _t->setCubemappingMode((*reinterpret_cast<std::add_pointer_t<S3DEnum::CubemappingMode>>(_a[1]))); break;
        case 48: { bool _r = _t->getUseFullCubemapShadows();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 49: _t->setUseFullCubemapShadows((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 50: _t->setEnableDebugInfo((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 51: { bool _r = _t->getEnableDebugInfo();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 52: _t->setEnableLocationInfo((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 53: { bool _r = _t->getEnableLocationInfo();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 54: _t->setLocationInfoStyle((*reinterpret_cast<std::add_pointer_t<S3DRenderer::LocationInfoStyle>>(_a[1]))); break;
        case 55: { S3DRenderer::LocationInfoStyle _r = _t->getLocationInfoStyle();
            if (_a[0]) *reinterpret_cast<S3DRenderer::LocationInfoStyle*>(_a[0]) = std::move(_r); }  break;
        case 56: _t->setForceHorizonPolyline((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 57: { bool _r = _t->getForceHorizonPolyline();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 58: _t->setEnableTorchLight((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 59: { bool _r = _t->getEnableTorchLight();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 60: _t->setTorchStrength((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 61: { float _r = _t->getTorchStrength();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 62: _t->setTorchRange((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 63: { float _r = _t->getTorchRange();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 64: _t->setDirectionalLightPush((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 65: { float _r = _t->getDirectionalLightPush();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 66: _t->setIgnoreInitialView((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 67: { bool _r = _t->getIgnoreInitialView();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 68: _t->setEnableLazyDrawing((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 69: { bool _r = _t->getEnableLazyDrawing();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 70: _t->setOnlyDominantFaceWhenMoving((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 71: { bool _r = _t->getOnlyDominantFaceWhenMoving();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 72: _t->setSecondDominantFaceWhenMoving((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 73: { bool _r = _t->getSecondDominantFaceWhenMoving();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 74: _t->forceCubemapRedraw(); break;
        case 75: _t->setLazyDrawingInterval((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 76: { double _r = _t->getLazyDrawingInterval();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 77: _t->setCubemapSize((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 78: { uint _r = _t->getCubemapSize();
            if (_a[0]) *reinterpret_cast<uint*>(_a[0]) = std::move(_r); }  break;
        case 79: _t->setShadowmapSize((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 80: { uint _r = _t->getShadowmapSize();
            if (_a[0]) *reinterpret_cast<uint*>(_a[0]) = std::move(_r); }  break;
        case 81: { bool _r = _t->getIsGeometryShaderSupported();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 82: { bool _r = _t->getAreShadowsSupported();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 83: { bool _r = _t->getIsShadowFilteringSupported();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 84: { bool _r = _t->getIsANGLE();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 85: { uint _r = _t->getMaximumFramebufferSize();
            if (_a[0]) *reinterpret_cast<uint*>(_a[0]) = std::move(_r); }  break;
        case 86: { SceneInfo _r = _t->getCurrentScene();
            if (_a[0]) *reinterpret_cast<SceneInfo*>(_a[0]) = std::move(_r); }  break;
        case 87: { QString _r = _t->getCurrentSceneID();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 88: { QString _r = _t->getLoadingSceneID();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 89: { SceneInfo _r = _t->getLoadingScene();
            if (_a[0]) *reinterpret_cast<SceneInfo*>(_a[0]) = std::move(_r); }  break;
        case 90: { SceneInfo _r = _t->loadScenery3dByName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<SceneInfo*>(_a[0]) = std::move(_r); }  break;
        case 91: { SceneInfo _r = _t->loadScenery3dByID((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<SceneInfo*>(_a[0]) = std::move(_r); }  break;
        case 92: { QString _r = _t->getDefaultScenery3dID();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 93: _t->setDefaultScenery3dID((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 94: _t->setView((*reinterpret_cast<std::add_pointer_t<StoredView>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 95: { StoredView _r = _t->getCurrentView();
            if (_a[0]) *reinterpret_cast<StoredView*>(_a[0]) = std::move(_r); }  break;
        case 96: _t->clearMessage(); break;
        case 97: _t->loadSceneCompleted(); break;
        case 98: _t->progressReceive((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 99: _t->loadScene((*reinterpret_cast<std::add_pointer_t<SceneInfo>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 24:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< SceneInfo >(); break;
            }
            break;
        case 28:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3d >(); break;
            }
            break;
        case 99:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< SceneInfo >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const bool )>(_a, &Scenery3d::enableSceneChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const bool )>(_a, &Scenery3d::enablePixelLightingChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const bool )>(_a, &Scenery3d::enableShadowsChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const bool )>(_a, &Scenery3d::useSimpleShadowsChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const bool )>(_a, &Scenery3d::enableBumpsChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const S3DEnum::ShadowFilterQuality )>(_a, &Scenery3d::shadowFilterQualityChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const bool )>(_a, &Scenery3d::enablePCSSChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const S3DEnum::CubemappingMode )>(_a, &Scenery3d::cubemappingModeChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const bool )>(_a, &Scenery3d::useFullCubemapShadowsChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const bool )>(_a, &Scenery3d::enableDebugInfoChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const bool )>(_a, &Scenery3d::enableLocationInfoChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(S3DRenderer::LocationInfoStyle )>(_a, &Scenery3d::locationInfoStyleChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const bool )>(_a, &Scenery3d::forceHorizonPolylineChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const bool )>(_a, &Scenery3d::enableTorchLightChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const float )>(_a, &Scenery3d::torchStrengthChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const float )>(_a, &Scenery3d::torchRangeChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const float )>(_a, &Scenery3d::directionalLightPushChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const bool )>(_a, &Scenery3d::ignoreInitialViewChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const bool )>(_a, &Scenery3d::enableLazyDrawingChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const double )>(_a, &Scenery3d::lazyDrawingIntervalChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const bool )>(_a, &Scenery3d::onlyDominantFaceWhenMovingChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const bool )>(_a, &Scenery3d::secondDominantFaceWhenMovingChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const uint )>(_a, &Scenery3d::cubemapSizeChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const uint )>(_a, &Scenery3d::shadowmapSizeChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const SceneInfo & )>(_a, &Scenery3d::currentSceneChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const QString & )>(_a, &Scenery3d::currentSceneIDChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const QString & )>(_a, &Scenery3d::loadingSceneIDChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (Scenery3d::*)(const QString & , int , int , int ) const>(_a, &Scenery3d::progressReport, 27))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->getEnableScene(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->getEnablePixelLighting(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->getEnableShadows(); break;
        case 3: *reinterpret_cast<bool*>(_v) = _t->getUseSimpleShadows(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->getEnableBumps(); break;
        case 5: *reinterpret_cast<S3DEnum::ShadowFilterQuality*>(_v) = _t->getShadowFilterQuality(); break;
        case 6: *reinterpret_cast<bool*>(_v) = _t->getEnablePCSS(); break;
        case 7: *reinterpret_cast<S3DEnum::CubemappingMode*>(_v) = _t->getCubemappingMode(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->getUseFullCubemapShadows(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->getEnableDebugInfo(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->getEnableLocationInfo(); break;
        case 11: *reinterpret_cast<S3DRenderer::LocationInfoStyle*>(_v) = _t->getLocationInfoStyle(); break;
        case 12: *reinterpret_cast<bool*>(_v) = _t->getForceHorizonPolyline(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->getEnableTorchLight(); break;
        case 14: *reinterpret_cast<float*>(_v) = _t->getTorchStrength(); break;
        case 15: *reinterpret_cast<float*>(_v) = _t->getTorchRange(); break;
        case 16: *reinterpret_cast<float*>(_v) = _t->getDirectionalLightPush(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->getIgnoreInitialView(); break;
        case 18: *reinterpret_cast<bool*>(_v) = _t->getEnableLazyDrawing(); break;
        case 19: *reinterpret_cast<double*>(_v) = _t->getLazyDrawingInterval(); break;
        case 20: *reinterpret_cast<bool*>(_v) = _t->getOnlyDominantFaceWhenMoving(); break;
        case 21: *reinterpret_cast<bool*>(_v) = _t->getSecondDominantFaceWhenMoving(); break;
        case 22: *reinterpret_cast<uint*>(_v) = _t->getCubemapSize(); break;
        case 23: *reinterpret_cast<uint*>(_v) = _t->getShadowmapSize(); break;
        case 24: *reinterpret_cast<QString*>(_v) = _t->getCurrentSceneID(); break;
        case 25: *reinterpret_cast<QString*>(_v) = _t->getLoadingSceneID(); break;
        case 26: *reinterpret_cast<bool*>(_v) = _t->getIsGeometryShaderSupported(); break;
        case 27: *reinterpret_cast<bool*>(_v) = _t->getAreShadowsSupported(); break;
        case 28: *reinterpret_cast<bool*>(_v) = _t->getIsShadowFilteringSupported(); break;
        case 29: *reinterpret_cast<bool*>(_v) = _t->getIsANGLE(); break;
        case 30: *reinterpret_cast<uint*>(_v) = _t->getMaximumFramebufferSize(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setEnableScene(*reinterpret_cast<bool*>(_v)); break;
        case 1: _t->setEnablePixelLighting(*reinterpret_cast<bool*>(_v)); break;
        case 2: _t->setEnableShadows(*reinterpret_cast<bool*>(_v)); break;
        case 3: _t->setUseSimpleShadows(*reinterpret_cast<bool*>(_v)); break;
        case 4: _t->setEnableBumps(*reinterpret_cast<bool*>(_v)); break;
        case 5: _t->setShadowFilterQuality(*reinterpret_cast<S3DEnum::ShadowFilterQuality*>(_v)); break;
        case 6: _t->setEnablePCSS(*reinterpret_cast<bool*>(_v)); break;
        case 7: _t->setCubemappingMode(*reinterpret_cast<S3DEnum::CubemappingMode*>(_v)); break;
        case 8: _t->setUseFullCubemapShadows(*reinterpret_cast<bool*>(_v)); break;
        case 9: _t->setEnableDebugInfo(*reinterpret_cast<bool*>(_v)); break;
        case 10: _t->setEnableLocationInfo(*reinterpret_cast<bool*>(_v)); break;
        case 11: _t->setLocationInfoStyle(*reinterpret_cast<S3DRenderer::LocationInfoStyle*>(_v)); break;
        case 12: _t->setForceHorizonPolyline(*reinterpret_cast<bool*>(_v)); break;
        case 13: _t->setEnableTorchLight(*reinterpret_cast<bool*>(_v)); break;
        case 14: _t->setTorchStrength(*reinterpret_cast<float*>(_v)); break;
        case 15: _t->setTorchRange(*reinterpret_cast<float*>(_v)); break;
        case 16: _t->setDirectionalLightPush(*reinterpret_cast<float*>(_v)); break;
        case 17: _t->setIgnoreInitialView(*reinterpret_cast<bool*>(_v)); break;
        case 18: _t->setEnableLazyDrawing(*reinterpret_cast<bool*>(_v)); break;
        case 19: _t->setLazyDrawingInterval(*reinterpret_cast<double*>(_v)); break;
        case 20: _t->setOnlyDominantFaceWhenMoving(*reinterpret_cast<bool*>(_v)); break;
        case 21: _t->setSecondDominantFaceWhenMoving(*reinterpret_cast<bool*>(_v)); break;
        case 22: _t->setCubemapSize(*reinterpret_cast<uint*>(_v)); break;
        case 23: _t->setShadowmapSize(*reinterpret_cast<uint*>(_v)); break;
        default: break;
        }
    }
}

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

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

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

// SIGNAL 0
void Scenery3d::enableSceneChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void Scenery3d::enablePixelLightingChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

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

// SIGNAL 3
void Scenery3d::useSimpleShadowsChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void Scenery3d::enableBumpsChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void Scenery3d::shadowFilterQualityChanged(const S3DEnum::ShadowFilterQuality _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void Scenery3d::enablePCSSChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void Scenery3d::cubemappingModeChanged(const S3DEnum::CubemappingMode _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void Scenery3d::useFullCubemapShadowsChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void Scenery3d::enableDebugInfoChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void Scenery3d::enableLocationInfoChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void Scenery3d::locationInfoStyleChanged(S3DRenderer::LocationInfoStyle _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void Scenery3d::forceHorizonPolylineChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void Scenery3d::enableTorchLightChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void Scenery3d::torchStrengthChanged(const float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void Scenery3d::torchRangeChanged(const float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

// SIGNAL 16
void Scenery3d::directionalLightPushChanged(const float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
}

// SIGNAL 17
void Scenery3d::ignoreInitialViewChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

// SIGNAL 18
void Scenery3d::enableLazyDrawingChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 19
void Scenery3d::lazyDrawingIntervalChanged(const double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1);
}

// SIGNAL 20
void Scenery3d::onlyDominantFaceWhenMovingChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void Scenery3d::secondDominantFaceWhenMovingChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void Scenery3d::cubemapSizeChanged(const uint _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void Scenery3d::shadowmapSizeChanged(const uint _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void Scenery3d::currentSceneChanged(const SceneInfo & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}

// SIGNAL 25
void Scenery3d::currentSceneIDChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1);
}

// SIGNAL 26
void Scenery3d::loadingSceneIDChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 26, nullptr, _t1);
}

// SIGNAL 27
void Scenery3d::progressReport(const QString & _t1, int _t2, int _t3, int _t4)const
{
    QMetaObject::activate<void>(const_cast< Scenery3d *>(this), &staticMetaObject, 27, nullptr, _t1, _t2, _t3, _t4);
}
namespace {
struct qt_meta_tag_ZN28Scenery3dStelPluginInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto Scenery3dStelPluginInterface::qt_create_metaobjectdata<qt_meta_tag_ZN28Scenery3dStelPluginInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Scenery3dStelPluginInterface"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Scenery3dStelPluginInterface, qt_meta_tag_ZN28Scenery3dStelPluginInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Scenery3dStelPluginInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28Scenery3dStelPluginInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28Scenery3dStelPluginInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN28Scenery3dStelPluginInterfaceE_t>.metaTypes,
    nullptr
} };

void Scenery3dStelPluginInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Scenery3dStelPluginInterface *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *Scenery3dStelPluginInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28Scenery3dStelPluginInterfaceE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "StelPluginInterface"))
        return static_cast< StelPluginInterface*>(this);
    if (!strcmp(_clname, "org.stellarium.StelPluginInterface/2.0"))
        return static_cast< StelPluginInterface*>(this);
    return QObject::qt_metacast(_clname);
}

int Scenery3dStelPluginInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}

#ifdef QT_MOC_EXPORT_PLUGIN_V2
static constexpr unsigned char qt_pluginMetaDataV2_Scenery3dStelPluginInterface[] = {
    0xbf, 
    // "IID"
    0x02,  0x78,  0x26,  'o',  'r',  'g',  '.',  's', 
    't',  'e',  'l',  'l',  'a',  'r',  'i',  'u', 
    'm',  '.',  'S',  't',  'e',  'l',  'P',  'l', 
    'u',  'g',  'i',  'n',  'I',  'n',  't',  'e', 
    'r',  'f',  'a',  'c',  'e',  '/',  '2',  '.', 
    '0', 
    // "className"
    0x03,  0x78,  0x1c,  'S',  'c',  'e',  'n',  'e', 
    'r',  'y',  '3',  'd',  'S',  't',  'e',  'l', 
    'P',  'l',  'u',  'g',  'i',  'n',  'I',  'n', 
    't',  'e',  'r',  'f',  'a',  'c',  'e', 
    0xff, 
};
QT_MOC_EXPORT_PLUGIN_V2(Scenery3dStelPluginInterface, Scenery3dStelPluginInterface, qt_pluginMetaDataV2_Scenery3dStelPluginInterface)
#else
QT_PLUGIN_METADATA_SECTION
Q_CONSTINIT static constexpr unsigned char qt_pluginMetaData_Scenery3dStelPluginInterface[] = {
    'Q', 'T', 'M', 'E', 'T', 'A', 'D', 'A', 'T', 'A', ' ', '!',
    // metadata version, Qt version, architectural requirements
    0, QT_VERSION_MAJOR, QT_VERSION_MINOR, qPluginArchRequirements(),
    0xbf, 
    // "IID"
    0x02,  0x78,  0x26,  'o',  'r',  'g',  '.',  's', 
    't',  'e',  'l',  'l',  'a',  'r',  'i',  'u', 
    'm',  '.',  'S',  't',  'e',  'l',  'P',  'l', 
    'u',  'g',  'i',  'n',  'I',  'n',  't',  'e', 
    'r',  'f',  'a',  'c',  'e',  '/',  '2',  '.', 
    '0', 
    // "className"
    0x03,  0x78,  0x1c,  'S',  'c',  'e',  'n',  'e', 
    'r',  'y',  '3',  'd',  'S',  't',  'e',  'l', 
    'P',  'l',  'u',  'g',  'i',  'n',  'I',  'n', 
    't',  'e',  'r',  'f',  'a',  'c',  'e', 
    0xff, 
};
QT_MOC_EXPORT_PLUGIN(Scenery3dStelPluginInterface, Scenery3dStelPluginInterface)
#endif  // QT_MOC_EXPORT_PLUGIN_V2

QT_WARNING_POP
