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() = default;

            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() = default;

            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() = default;

            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