simconnectobject.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_SIMPLUGIN_FSXCOMMON_SIMCONNECTOBJECT_H
#define SWIFT_SIMPLUGIN_FSXCOMMON_SIMCONNECTOBJECT_H
 
#include <QByteArray>
#include <QSharedPointer>
#include <QStringList>
 
#include "misc/simulation/interpolation/interpolatormulti.h"
#include "misc/simulation/simulatedaircraft.h"
#include "plugins/simulator/fsxcommon/fsxcommonexport.h"
#include "plugins/simulator/fsxcommon/simconnectdatadefinition.h"
 
namespace swift::simplugin::fsxcommon
{
    class FSXCOMMON_EXPORT CSimConnectObject
    {
    public:
        enum SimObjectType
        {
            AircraftNonAtc,
            AircraftSimulatedObject,
            TerrainProbe,
            AllTypes
        };
 
        CSimConnectObject();
 
        CSimConnectObject(SimObjectType type);
 
        CSimConnectObject(const swift::misc::simulation::CSimulatedAircraft &aircraft, DWORD requestId,
                          swift::misc::simulation::ISimulationEnvironmentProvider *simEnvProvider,
                          swift::misc::simulation::IInterpolationSetupProvider *setupProvider,
                          swift::misc::simulation::IRemoteAircraftProvider *remoteAircraftProvider,
                          swift::misc::simulation::CInterpolationLogger *logger);
 
        const swift::misc::aviation::CCallsign &getCallsign() const { return m_aircraft.getCallsign(); }
 
        const QString &getCallsignAsString() const { return m_aircraft.getCallsign().asString(); }
 
        bool hasCallsign() const { return !this->getCallsign().isEmpty(); }
 
        const swift::misc::simulation::CSimulatedAircraft &getAircraft() const { return m_aircraft; }
 
        const swift::misc::simulation::CAircraftModel &getAircraftModel() const { return m_aircraft.getModel(); }
 
        const QString &getAircraftModelString() const { return m_aircraft.getModelString(); }
 
        SimObjectType getType() const { return m_type; }
 
        const QString &getTypeAsString() const { return typeToString(m_type); }
 
        bool isAircraft() const
        {
            return this->getType() == AircraftNonAtc || this->getType() == AircraftSimulatedObject;
        }
 
        bool isAircraftSimulatedObject() const { return this->getType() == AircraftSimulatedObject; }
 
        bool isAircraftNonAtc() const { return this->getType() == AircraftNonAtc; }
 
        bool isTerrainProbe() const { return this->getType() == TerrainProbe; }
 
        void setType(SimObjectType type) { m_type = type; }
 
        void setAircraft(const swift::misc::simulation::CSimulatedAircraft &aircraft);
 
        void setAircraftModelString(const QString &modelString);
 
        void setAircraftCG(const swift::misc::physical_quantities::CLength &cg);
 
        const swift::misc::aviation::CAircraftLights &getCurrentLightsInSimulator() const
        {
            return m_currentLightsInSim;
        }
 
        bool hasCurrentLightsInSimulator() const { return !m_currentLightsInSim.isNull(); }
 
        void setCurrentLightsInSimulator(const swift::misc::aviation::CAircraftLights &lights)
        {
            m_currentLightsInSim = lights;
        }
 
        void fakeCurrentLightsInSimulator() { m_currentLightsInSim.setNull(false); }
 
        const swift::misc::aviation::CAircraftLights &getLightsAsSent() const { return m_lightsAsSent; }
 
        void setLightsAsSent(const swift::misc::aviation::CAircraftLights &lights) { m_lightsAsSent = lights; }
 
        SIMCONNECT_PERIOD getSimDataPeriod() const { return m_requestSimDataPeriod; }
 
        void setSimDataPeriod(SIMCONNECT_PERIOD period) { m_requestSimDataPeriod = period; }
 
        void setRequestId(DWORD id);
 
        DWORD getRequestId() const { return m_requestId; }
 
        DWORD getRequestId(CSimConnectDefinitions::SimObjectRequest offset) const;
 
        void setObjectId(DWORD id);
 
        DWORD getObjectId() const { return m_objectId; }
 
        QString getObjectIdAsString() const { return QString::number(this->getObjectId()); }
 
        bool hasValidRequestId() const { return m_validRequestId; }
 
        bool hasValidObjectId() const { return m_validObjectId; }
 
        bool isPendingAdded() const;
 
        bool isOutdatedPendingAdded(qint64 thresholdMs = 5000, qint64 currentMsSinceEpoch = -1) const;
 
        bool isConfirmedAdded() const;
 
        void setConfirmedAdded(bool confirm);
 
        bool isAddedWhileRemoving() { return m_addedWhileRemoving; }
        void setAddedWhileRemoving(bool addedWileRemoved);
        bool isRemovedWhileAdding() const { return m_removedWhileAdding; }
        void setRemovedWhileAdding(bool removedWhileAdding);
 
        bool isPendingRemoved() const { return m_pendingRemoved; }
 
        bool isReadyToSend() const;
 
        void setPendingRemoved(bool pending);
 
        bool isPending() const { return this->isPendingAdded() || this->isPendingRemoved(); }
 
        bool hasCamera() const { return m_camera; }
 
        void resetCameraPositions();
 
        const SIMCONNECT_DATA_XYZ &cameraPosition() const { return m_cameraPosition; }
 
        const SIMCONNECT_DATA_PBH &cameraRotation() const { return m_cameraRotation; }
 
        void setCameraPositionAndRotation(const SIMCONNECT_DATA_XYZ &position, const SIMCONNECT_DATA_PBH &rotation)
        {
            m_cameraPosition = position;
            m_cameraRotation = rotation;
        }
 
        GUID getCameraGUID() const { return m_cameraGuid; }
 
        void setCameraGUID(GUID guid)
        {
            m_cameraGuid = guid;
            m_camera = true;
        }
 
        void removeCamera() { m_camera = false; }
 
        void setObserverName(const QString &observer) { m_observerName = observer; }
 
        const QString &getObserverName() const { return m_observerName; }
 
        void resetState();
 
        void resetToAddAgain();
 
        void resetTimestampToNow() { m_tsCreated = QDateTime::currentMSecsSinceEpoch(); }
 
        bool isVtol() const { return m_aircraft.isVtol(); }
 
        bool isValid() const { return !this->isInvalid(); }
 
        bool isInvalid() const { return !this->hasValidObjectId() && !this->hasValidRequestId(); }
 
        bool hasCreatedTimestamp() const { return m_tsCreated >= 0; }
 
        qint64 getCreatedTimestamp() const { return m_tsCreated; }
 
        int getEngineCount() const { return m_aircraft.getEnginesCount(); }
 
        bool hasValidRequestAndObjectId() const;
 
        int getAddingExceptions() const { return m_addingExceptions; }
 
        void setAddingExceptions(int number) { m_addingExceptions = number; }
 
        void increaseAddingExceptions() { m_addingExceptions++; }
 
        void decreaseAddingExceptions()
        {
            if (m_addingExceptions > 0) { m_addingExceptions--; }
        }
 
        int getAddingDirectlyRemoved() const { return m_addingDirectlyRemoved; }
 
        void setAddingDirectlyRemoved(int number) { m_addingDirectlyRemoved = number; }
 
        void increaseAddingDirectlyRemoved() { m_addingDirectlyRemoved++; }
 
        void copyAddingFailureCounters(const CSimConnectObject &otherObject);
 
        const QByteArray &getCallsignByteArray() const { return m_callsignByteArray; }
 
        QString
        getInterpolatorInfo(swift::misc::simulation::CInterpolationAndRenderingSetupBase::InterpolatorMode mode) const;
 
        void attachInterpolatorLogger(swift::misc::simulation::CInterpolationLogger *logger) const;
 
        swift::misc::simulation::CInterpolationResult
        getInterpolation(qint64 currentTimeSinceEpoch,
                         const swift::misc::simulation::CInterpolationAndRenderingSetupPerCallsign &setup,
                         uint32_t aircraftNumber) const;
 
        const swift::misc::aviation::CAircraftSituation &getLastInterpolatedSituation(
            swift::misc::simulation::CInterpolationAndRenderingSetupBase::InterpolatorMode mode) const;
 
        const swift::misc::CStatusMessageList &getInterpolationMessages(
            swift::misc::simulation::CInterpolationAndRenderingSetupBase::InterpolatorMode mode) const;
 
        swift::misc::simulation::CInterpolatorMulti *getInterpolator() const { return m_interpolator.data(); }
 
        QString toQString() const;
 
        static SimObjectType requestIdToType(DWORD requestId);
 
        static const QString &typeToString(SimObjectType type);
 
        static bool isSameTypeGroup(SimObjectType t1, SimObjectType t2);
 
        static bool isAircraft(SimObjectType type);
 
    private:
        swift::misc::simulation::CSimulatedAircraft m_aircraft; 
        SimObjectType m_type = AircraftNonAtc;
        DWORD m_requestId = 0;
        DWORD m_objectId = 0;
        bool m_validRequestId = false;
        bool m_validObjectId = false;
        bool m_confirmedAdded = false;
        bool m_pendingRemoved = false;
        bool m_camera = false;
        bool m_removedWhileAdding = false;
        bool m_addedWhileRemoving = false;
        int m_addingExceptions = 0; 
        int m_addingDirectlyRemoved = 0; 
        qint64 m_tsCreated = -1;
        GUID m_cameraGuid;
        SIMCONNECT_DATA_XYZ m_cameraPosition;
        SIMCONNECT_DATA_PBH m_cameraRotation;
        QByteArray m_callsignByteArray;
        QString m_observerName;
        swift::misc::aviation::CAircraftLights m_currentLightsInSim {
            nullptr
        }; 
        swift::misc::aviation::CAircraftLights m_lightsAsSent { nullptr }; 
        SIMCONNECT_PERIOD m_requestSimDataPeriod = SIMCONNECT_PERIOD_NEVER; 
        QSharedPointer<swift::misc::simulation::CInterpolatorMulti>
            m_interpolator; 
    };
 
    class CSimConnectObjects : public QHash<swift::misc::aviation::CCallsign, CSimConnectObject>
    {
    public:
        bool insert(const CSimConnectObject &simObject, bool updateTimestamp = false);
 
        bool setSimConnectObjectIdForRequestId(DWORD requestId, DWORD objectId);
 
        swift::misc::aviation::CCallsign getCallsignForObjectId(DWORD objectId) const;
 
        CSimConnectObject getSimObjectForObjectId(DWORD objectId) const;
 
        CSimConnectObject getSimObjectForRequestId(DWORD requestId) const;
 
        CSimConnectObject getSimObjectForOtherSimObject(const CSimConnectObject &otherSimObj) const;
 
        CSimConnectObject getOldestObject() const;
 
        bool isKnownSimObjectId(DWORD objectId) const;
 
        bool removeByObjectId(DWORD objectId);
 
        bool removeByOtherSimObject(const CSimConnectObject &otherSimObj);
 
        int removeAllProbes();
 
        int removeCallsigns(const swift::misc::aviation::CCallsignSet &callsigns);
 
        CSimConnectObjects removeOutdatedPendingAdded(CSimConnectObject::SimObjectType type);
 
        bool containsPendingAdded() const;
 
        bool containsPendingRemoved() const;
 
        int countPendingAdded() const;
 
        int countPendingRemoved() const;
 
        int countConfirmedAdded();
 
        swift::misc::aviation::CCallsignSet getAllCallsigns(bool withoutProbes = true) const;
 
        QStringList getAllCallsignStrings(bool sorted = false, bool withoutProbes = true) const;
 
        QString getAllCallsignStringsAsString(bool sorted = false, const QString &separator = ", ") const;
 
        swift::misc::aviation::CCallsignSet getPendingAddedCallsigns() const;
 
        swift::misc::aviation::CCallsignSet getPendingRemovedCallsigns() const;
 
        QList<CSimConnectObject> getByType(CSimConnectObject::SimObjectType type) const;
 
        QList<CSimConnectObject> getProbes() const { return this->getByType(CSimConnectObject::TerrainProbe); }
 
        QList<CSimConnectObject> getAircraft() const;
 
        CSimConnectObject getNotPendingProbe() const;
 
        CSimConnectObject getOldestNotPendingProbe() const;
 
        bool containsType(CSimConnectObject::SimObjectType type) const;
 
        bool containsProbe() const { return this->containsType(CSimConnectObject::TerrainProbe); }
 
        bool containsAircraft() const;
    };
} // namespace swift::simplugin::fsxcommon
 
#endif // SWIFT_SIMPLUGIN_FSXCOMMON_SIMCONNECTOBJECT_H