interpolationrenderingsetup.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2016 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_SIMULATION_INTERPOLATION_INTERPOLATIONRENDERINGSETUP_H
#define SWIFT_MISC_SIMULATION_INTERPOLATION_INTERPOLATIONRENDERINGSETUP_H
 
#include <QString>
 
#include "misc/aviation/callsign.h"
#include "misc/pq/angle.h"
#include "misc/pq/length.h"
#include "misc/propertyindexlist.h"
#include "misc/swiftmiscexport.h"
#include "misc/valueobject.h"
 
SWIFT_DECLARE_VALUEOBJECT_MIXINS(swift::misc::simulation, CInterpolationAndRenderingSetupGlobal)
SWIFT_DECLARE_VALUEOBJECT_MIXINS(swift::misc::simulation, CInterpolationAndRenderingSetupPerCallsign)
 
namespace swift::misc
{
    namespace network
    {
        class CClient;
    }
    namespace simulation
    {
        class SWIFT_MISC_EXPORT CInterpolationAndRenderingSetupBase
        {
        public:
            enum ColumnIndex
            {
                IndexLogInterpolation = CPropertyIndexRef::GlobalIndexCInterpolatioRenderingSetup,
                IndexSimulatorDebugMessages,
                IndexForceFullInterpolation,
                IndexSendGndFlagToSimulator,
                IndexEnabledAircraftParts,
                IndexInterpolatorMode,
                IndexInterpolatorModeAsString,
                IndexFixSceneryOffset,
                IndexPitchOnGround
            };
 
            enum InterpolatorMode
            {
                Spline,
                Linear
            };
 
            bool showSimulatorDebugMessages() const { return m_simulatorDebugMessages; }
 
            void setSimulatorDebuggingMessages(bool debug) { m_simulatorDebugMessages = debug; }
 
            bool logInterpolation() const { return m_logInterpolation; }
 
            bool setLogInterpolation(bool log);
 
            bool isForcingFullInterpolation() const { return m_forceFullInterpolation; }
 
            void setForceFullInterpolation(bool force) { m_forceFullInterpolation = force; }
 
            bool setEnabledAircraftParts(bool enabled);
 
            bool maskEnabledAircraftParts(bool mask);
 
            bool isAircraftPartsEnabled() const { return m_enabledAircraftParts; }
 
            bool isSendingGndFlagToSimulator() const { return m_sendGndToSim; }
 
            bool setSendingGndFlagToSimulator(bool sendFLag);
 
            bool isFixingSceneryOffset() const { return m_fixSceneryOffset; }
 
            void setFixingSceneryOffset(bool fix) { m_fixSceneryOffset = fix; }
 
            const physical_quantities::CAngle &getPitchOnGround() const { return m_pitchOnGround; }
 
            bool setPitchOnGround(const physical_quantities::CAngle &pitchOnGround);
 
            void consolidateWithClient(const network::CClient &client);
 
            InterpolatorMode getInterpolatorMode() const { return static_cast<InterpolatorMode>(m_interpolatorMode); }
 
            const QString &getInterpolatorModeAsString() const { return modeToString(this->getInterpolatorMode()); }
 
            bool setInterpolatorMode(InterpolatorMode mode);
 
            bool setInterpolatorMode(const QString &mode);
 
            QString convertToQString(bool i18n = false) const;
 
            QVariant propertyByIndex(CPropertyIndexRef index) const;
 
            void setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant);
 
            static const QString &modeToString(InterpolatorMode mode);
 
        protected:
            CInterpolationAndRenderingSetupBase();
 
            static bool canHandleIndex(int index);
 
            bool m_logInterpolation = false; 
            bool m_simulatorDebugMessages = false; 
            bool m_forceFullInterpolation = false; 
            bool m_enabledAircraftParts = true; 
            bool m_sendGndToSim = true; 
            bool m_fixSceneryOffset = false; 
            int m_interpolatorMode = static_cast<int>(Spline); 
            physical_quantities::CAngle m_pitchOnGround =
                physical_quantities::CAngle::null(); 
        };
 
        class SWIFT_MISC_EXPORT CInterpolationAndRenderingSetupGlobal :
            public CValueObject<CInterpolationAndRenderingSetupGlobal>,
            public CInterpolationAndRenderingSetupBase
        {
        public:
            enum ColumnIndex
            {
                IndexMaxRenderedAircraft = CInterpolationAndRenderingSetupBase::IndexFixSceneryOffset + 1,
                IndexMaxRenderedDistance
            };
 
            CInterpolationAndRenderingSetupGlobal();
 
            static int InfiniteAircraft();
 
            int getMaxRenderedAircraft() const;
 
            bool setMaxRenderedAircraft(int maxRenderedAircraft);
 
            bool setMaxRenderedDistance(const physical_quantities::CLength &distance);
 
            void clearMaxRenderedDistance();
 
            bool isRenderingEnabled() const;
 
            bool isRenderingRestricted() const;
 
            physical_quantities::CLength getMaxRenderedDistance() const { return m_maxRenderedDistance; }
 
            bool isMaxDistanceRestricted() const;
 
            bool isMaxAircraftRestricted() const;
 
            void clearAllRenderingRestrictions();
 
            void disableRendering();
 
            QString getRenderRestrictionText() const;
 
            void setBaseValues(const CInterpolationAndRenderingSetupBase &baseValues);
 
            QString convertToQString(bool i18n = false) const;
 
            QVariant propertyByIndex(CPropertyIndexRef index) const;
 
            void setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant);
 
        private:
            int m_maxRenderedAircraft = InfiniteAircraft(); 
            physical_quantities::CLength m_maxRenderedDistance { 0, nullptr }; 
 
            SWIFT_METACLASS(
                CInterpolationAndRenderingSetupGlobal,
                SWIFT_METAMEMBER(logInterpolation),
                SWIFT_METAMEMBER(simulatorDebugMessages),
                SWIFT_METAMEMBER(forceFullInterpolation),
                SWIFT_METAMEMBER(sendGndToSim),
                SWIFT_METAMEMBER(enabledAircraftParts),
                SWIFT_METAMEMBER(fixSceneryOffset),
                SWIFT_METAMEMBER(interpolatorMode),
                SWIFT_METAMEMBER(pitchOnGround),
                SWIFT_METAMEMBER(maxRenderedAircraft),
                SWIFT_METAMEMBER(maxRenderedDistance));
        };
 
        class SWIFT_MISC_EXPORT CInterpolationAndRenderingSetupPerCallsign :
            public CValueObject<CInterpolationAndRenderingSetupPerCallsign>,
            public CInterpolationAndRenderingSetupBase
        {
        public:
            enum ColumnIndex
            {
                IndexCallsign = CInterpolationAndRenderingSetupGlobal::IndexMaxRenderedDistance + 1
            };
 
            CInterpolationAndRenderingSetupPerCallsign();
 
            CInterpolationAndRenderingSetupPerCallsign(const aviation::CCallsign &callsign,
                                                       const CInterpolationAndRenderingSetupGlobal &globalSetup);
 
            CPropertyIndexList unequalToGlobal(const CInterpolationAndRenderingSetupGlobal &globalSetup) const;
 
            bool isEqualToGlobal(const CInterpolationAndRenderingSetupGlobal &globalSetup) const;
 
            const aviation::CCallsign &getCallsign() const { return m_callsign; }
 
            void setCallsign(const aviation::CCallsign &callsign) { m_callsign = callsign; }
 
            bool isNull() const { return m_callsign.isEmpty(); }
 
            QVariant propertyByIndex(CPropertyIndexRef index) const;
 
            void setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant);
 
            static const CInterpolationAndRenderingSetupPerCallsign &null();
 
        private:
            aviation::CCallsign m_callsign;
 
            SWIFT_METACLASS(
                CInterpolationAndRenderingSetupPerCallsign,
                SWIFT_METAMEMBER(logInterpolation),
                SWIFT_METAMEMBER(simulatorDebugMessages),
                SWIFT_METAMEMBER(forceFullInterpolation),
                SWIFT_METAMEMBER(sendGndToSim),
                SWIFT_METAMEMBER(enabledAircraftParts),
                SWIFT_METAMEMBER(fixSceneryOffset),
                SWIFT_METAMEMBER(interpolatorMode),
                SWIFT_METAMEMBER(pitchOnGround));
        };
    } // namespace simulation
} // namespace swift::misc
 
Q_DECLARE_METATYPE(swift::misc::simulation::CInterpolationAndRenderingSetupPerCallsign)
Q_DECLARE_METATYPE(swift::misc::simulation::CInterpolationAndRenderingSetupGlobal)
Q_DECLARE_METATYPE(swift::misc::simulation::CInterpolationAndRenderingSetupBase::InterpolatorMode)
 
#endif // SWIFT_MISC_SIMULATION_INTERPOLATION_INTERPOLATIONRENDERINGSETUP_H