flightsimulatorplatfrom/pilotclient
1
0
Fork 0
mirror of https://github.com/swift-project/pilotclient.git synced 2026-04-14 00:25:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

refs #395, prepared for logical / physical add/remote member functions

Browse Source 
* renamed functions
* added access to snapshot
* moved simulator base class in own files (.h/.cpp)
This commit is contained in:
Klaus Basan
2015-05-03 01:28:55 +02:00
committed by Mathew Sutcliffe
parent 91f0b99cc5
commit e9f7810efc
23 changed files with 641 additions and 470 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/blackcore/airspace_analyzer.cpp
View File

@@ -70,10 +70,10 @@ namespace BlackCore
m_aircraftCallsignTimestamps[situation.getCallsign()] = QDateTime::currentMSecsSinceEpoch();
}
void CAirspaceAnalyzer::ps_watchdogTouchAtcCallsign(const CCallsign &callsign, const CFrequency &freq, const Geo::CCoordinateGeodetic &pos, const CLength &range)
void CAirspaceAnalyzer::ps_watchdogTouchAtcCallsign(const CCallsign &callsign, const CFrequency &frequency, const Geo::CCoordinateGeodetic &position, const CLength &range)
{
Q_UNUSED(freq);
Q_UNUSED(pos);
Q_UNUSED(frequency);
Q_UNUSED(position);
Q_UNUSED(range);
m_atcCallsignTimestamps[callsign] = QDateTime::currentMSecsSinceEpoch();
}
@@ -150,7 +150,9 @@ namespace BlackCore
void CAirspaceAnalyzer::analyzeAirspace()
{
CAirspaceAircraftSnapshot snapshot(getAircraftInRange()); // thread safe copy
CAirspaceAircraftSnapshot snapshot(
getAircraftInRange() // thread safe copy
);
// lock block
{

6
src/blackcore/airspace_analyzer.h
View File

@@ -24,7 +24,7 @@
namespace BlackCore
{
//! Class monitoring and analyzing (closests aircraft, outdated aircraft / watchdog) airspace
//! Class monitoring and analyzing (closest aircraft, outdated aircraft / watchdog) airspace
//! in background.
//!
//! \details Watchdog functionality: This class was introduced due to a flaw in the VATSIM server implementation: Every client needs to send an add/delete packet on its own to inform other
@@ -76,8 +76,8 @@ namespace BlackCore
void ps_watchdogTouchAircraftCallsign(const BlackMisc::Aviation::CAircraftSituation &situation, const BlackMisc::Aviation::CTransponder &transponder);
//! Reset timestamp for callsign
void ps_watchdogTouchAtcCallsign(const BlackMisc::Aviation::CCallsign &callsign, const BlackMisc::PhysicalQuantities::CFrequency &freq,
const BlackMisc::Geo::CCoordinateGeodetic &pos, const BlackMisc::PhysicalQuantities::CLength &range);
void ps_watchdogTouchAtcCallsign(const BlackMisc::Aviation::CCallsign &callsign, const BlackMisc::PhysicalQuantities::CFrequency &frequency,
const BlackMisc::Geo::CCoordinateGeodetic &position, const BlackMisc::PhysicalQuantities::CLength &range);
//! Connection status of network changed
void ps_onConnectionStatusChanged(BlackCore::INetwork::ConnectionStatus oldStatus, BlackCore::INetwork::ConnectionStatus newStatus);

2
src/blackcore/airspace_monitor.h
View File

@@ -209,7 +209,7 @@ namespace BlackCore
INetwork *m_network = nullptr;
CVatsimBookingReader *m_vatsimBookingReader = nullptr;
CVatsimDataFileReader *m_vatsimDataFileReader = nullptr;
CAirspaceAnalyzer *m_analyzer = nullptr;
CAirspaceAnalyzer *m_analyzer = nullptr; //!< owned analyzer
bool m_serverSupportsNameQuery = false; //!< not all servers support name query
bool m_connected = false; //!< retrieve data
bool m_sendInterimPositions = false;

3
src/blackcore/context_network_impl.h
View File

@@ -92,6 +92,9 @@ namespace BlackCore
//! \ingroup remoteaircraftprovider
virtual BlackMisc::Simulation::CAirspaceAircraftSnapshot getLatestAirspaceAircraftSnapshot() const override;
//! Network library
INetwork* network() const { return m_network; }
public slots:
//! \copydoc IContextNetwork::updateAircraftEnabled
//! \ingroup remoteaircraftprovider

14
src/blackcore/context_simulator_impl.cpp
View File

@@ -401,10 +401,10 @@ namespace BlackCore
Q_ASSERT(networkContext);
Q_ASSERT(networkContext->isLocalObject());
for (const CSimulatedAircraft &simAircraft : networkContext->getAircraftInRange())
for (const CSimulatedAircraft &simulatedAircraft : networkContext->getAircraftInRange())
{
Q_ASSERT(!simAircraft.getCallsign().isEmpty());
m_simulatorPlugin->simulator->addRemoteAircraft(simAircraft);
Q_ASSERT(!simulatedAircraft.getCallsign().isEmpty());
m_simulatorPlugin->simulator->logicallyAddRemoteAircraft(simulatedAircraft);
}
// apply latest settings
@@ -565,7 +565,7 @@ namespace BlackCore
Q_ASSERT(m_simulatorPlugin->simulator);
Q_ASSERT(!remoteAircraft.getCallsign().isEmpty());
m_simulatorPlugin->simulator->addRemoteAircraft(remoteAircraft);
m_simulatorPlugin->simulator->logicallyAddRemoteAircraft(remoteAircraft);
}
void CContextSimulator::ps_removedRemoteAircraft(const CCallsign &callsign)
@@ -580,8 +580,7 @@ namespace BlackCore
}
Q_ASSERT(m_simulatorPlugin->simulator);
m_simulatorPlugin->simulator->removeRemoteAircraft(callsign);
m_simulatorPlugin->simulator->logicallyRemoveRemoteAircraft(callsign);
}
void CContextSimulator::ps_onSimulatorStatusChanged(int status)
@@ -615,10 +614,9 @@ namespace BlackCore
}
}
void CContextSimulator::ps_cockitChangedFromSim(const CSimulatedAircraft &ownAircraft)
void CContextSimulator::ps_cockpitChangedFromSimulator(const CSimulatedAircraft &ownAircraft)
{
Q_ASSERT(getIContextOwnAircraft());
getIContextOwnAircraft()->changedAircraftCockpit(ownAircraft, IContextSimulator::InterfaceName());
}

2
src/blackcore/context_simulator_impl.h
View File

@@ -180,7 +180,7 @@ namespace BlackCore
void ps_simulatorStarted(QObject *listener);
//! Simulator has changed cockpit
void ps_cockitChangedFromSim(const BlackMisc::Simulation::CSimulatedAircraft &ownAircraft);
void ps_cockpitChangedFromSimulator(const BlackMisc::Simulation::CSimulatedAircraft &ownAircraft);
//! Changed remote aircraft model
void ps_changedRemoteAircraftModel(const BlackMisc::Simulation::CSimulatedAircraft &aircraft, const QString &originator);

261
src/blackcore/simulator.cpp
View File

@@ -20,47 +20,14 @@ using namespace BlackMisc::Simulation;
namespace BlackCore
{
CSimulatorCommon::CSimulatorCommon(const CSimulatorPluginInfo &info,
BlackMisc::Simulation::IOwnAircraftProvider *ownAircraftProvider,
BlackMisc::Simulation::IRemoteAircraftProvider *remoteAircraftProvider,
QObject *parent)
: ISimulator(parent),
COwnAircraftAware(ownAircraftProvider),
CRemoteAircraftAware(remoteAircraftProvider),
m_simulatorPluginInfo(info)
const QString &ISimulator::simulatorOriginator()
{
this->setObjectName(info.getIdentifier());
m_oneSecondTimer = new QTimer(this);
m_oneSecondTimer->setObjectName(this->objectName().append(":m_oneSecondTimer"));
connect(this->m_oneSecondTimer, &QTimer::timeout, this, &CSimulatorCommon::ps_oneSecondTimer);
m_oneSecondTimer->start(1000);
// provider signals
bool c = remoteAircraftProvider->connectRemoteAircraftProviderSignals(
std::bind(&CSimulatorCommon::ps_remoteProviderAddAircraftSituation, this, std::placeholders::_1),
std::bind(&CSimulatorCommon::ps_remoteProvideraddAircraftParts, this, std::placeholders::_1),
std::bind(&CSimulatorCommon::ps_remoteProviderRemovedAircraft, this, std::placeholders::_1),
std::bind(&CSimulatorCommon::ps_remoteProviderAircraftSnapshot, this, std::placeholders::_1)
);
Q_ASSERT(c);
Q_UNUSED(c);
// info
CLogMessage(this).info("Initialized simulator driver %1") << m_simulatorPluginInfo.toQString();
// string is generated once, the timestamp allows to use multiple
// components (as long as they are not generated at the same ms)
static const QString o = QString("SIMULATOR:").append(QString::number(QDateTime::currentMSecsSinceEpoch()));
return o;
}
void ISimulator::ps_remoteProviderAddAircraftSituation(const CAircraftSituation &situation)
{ Q_UNUSED(situation); }
void ISimulator::ps_remoteProvideraddAircraftParts(const CAircraftParts &parts)
{ Q_UNUSED(parts); }
void ISimulator::ps_remoteProviderRemovedAircraft(const CCallsign &callsign)
{ Q_UNUSED(callsign); }
void ISimulator::ps_remoteProviderAircraftSnapshot(const CAirspaceAircraftSnapshot &aircraftSnapshot)
{ Q_UNUSED(aircraftSnapshot); }
void ISimulator::emitSimulatorCombinedStatus()
{
int status =
@@ -70,225 +37,7 @@ namespace BlackCore
emit simulatorStatusChanged(status);
}
void CSimulatorCommon::blinkHighlightedAircraft()
{
if (m_highlightedAircraft.isEmpty() || m_highlightEndTimeMsEpoch < 1) { return; }
m_blinkCycle = !m_blinkCycle;
if (QDateTime::currentMSecsSinceEpoch() < m_highlightEndTimeMsEpoch)
{
// blink mode, toggle aircraft
for (const CSimulatedAircraft &aircraft : m_highlightedAircraft)
{
if (m_blinkCycle)
{
this->removeRemoteAircraft(aircraft.getCallsign());
}
else
{
this->addRemoteAircraft(aircraft);
}
}
}
else
{
// restore
for (const CSimulatedAircraft &aircraft : m_highlightedAircraft)
{
// get the current state for this aircraft
// it might has been removed in the mean time
const CCallsign cs(aircraft.getCallsign());
resetAircraftFromBacked(cs);
}
m_highlightedAircraft.clear();
m_highlightEndTimeMsEpoch = 0;
}
}
void CSimulatorCommon::recalculateRestrictedAircraft()
{
if (!isMaxAircraftRestricted()) { return; }
if (!isRenderingEnabled()) { return; }
CSimulatedAircraftList newAircraftInRange(getAircraftInRange().getClosestObjects(getMaxRenderedAircraft()));
CCallsignSet newAircraftCallsigns(newAircraftInRange.getCallsigns());
CCallsignSet toBeRemovedCallsigns(m_callsignsToBeRendered.difference(newAircraftCallsigns));
CCallsignSet toBeAddedCallsigns(newAircraftCallsigns.difference(m_callsignsToBeRendered));
for (const CCallsign &cs : toBeRemovedCallsigns)
{
removeRemoteAircraft(cs);
}
for (const CCallsign &cs : toBeAddedCallsigns)
{
addRemoteAircraft(newAircraftInRange.findFirstByCallsign(cs));
}
this->m_callsignsToBeRendered = newAircraftCallsigns;
}
void CSimulatorCommon::resetAircraftFromBacked(const CCallsign &callsign)
{
CSimulatedAircraft aircraft(this->getAircraftInRangeForCallsign(callsign));
bool enabled = aircraft.isEnabled();
if (enabled)
{
// are we already visible?
if (!isRenderedAircraft(callsign))
{
this->addRemoteAircraft(aircraft);
}
}
else
{
removeRemoteAircraft(callsign);
}
}
void CSimulatorCommon::setInitialAircraftSituationAndParts(CSimulatedAircraft &aircraft) const
{
if (!this->m_interpolator) { return; }
const CCallsign callsign(aircraft.getCallsign());
if (!(this->remoteAircraftSituationsCount(callsign) < 1)) { return; }
// with an interpolator the interpolated situation is used
// to avoid position jittering
qint64 time = QDateTime::currentMSecsSinceEpoch();
IInterpolator::InterpolationStatus is;
CAircraftSituation as(m_interpolator->getInterpolatedSituation(callsign, time, aircraft.isVtol(), is));
if (is.interpolationSucceeded) { aircraft.setSituation(as); }
}
int CSimulatorCommon::getMaxRenderedAircraft() const
{
return (m_maxRenderedAircraft <= MaxAircraftInfinite) ? m_maxRenderedAircraft : MaxAircraftInfinite;
}
void CSimulatorCommon::setMaxRenderedAircraft(int maxRenderedAircraft)
{
if (maxRenderedAircraft == m_maxRenderedAircraft) { return; }
if (maxRenderedAircraft < 1)
{
m_maxRenderedAircraft = 0;
}
else if (maxRenderedAircraft >= MaxAircraftInfinite)
{
m_maxRenderedAircraft = MaxAircraftInfinite;
}
else
{
m_maxRenderedAircraft = maxRenderedAircraft;
}
bool r = isRenderingRestricted();
emit restrictedRenderingChanged(r);
}
void CSimulatorCommon::setMaxRenderedDistance(CLength &distance)
{
if (distance == m_maxRenderedDistance) { return; }
if (distance.isNull() || distance >= getRenderedDistanceBoundary())
{
m_maxRenderedDistance = CLength(0.0, CLengthUnit::nullUnit());
}
else
{
Q_ASSERT(distance.isPositiveWithEpsilonConsidered());
m_maxRenderedDistance = distance;
}
bool r = isRenderingRestricted();
emit restrictedRenderingChanged(r);
}
CLength CSimulatorCommon::getMaxRenderedDistance() const
{
if (m_maxRenderedDistance.isNull()) { return getRenderedDistanceBoundary(); }
return m_maxRenderedDistance;
}
CLength CSimulatorCommon::getRenderedDistanceBoundary() const
{
return CLength(20.0, CLengthUnit::NM());
}
bool CSimulatorCommon::isMaxAircraftRestricted() const
{
return m_maxRenderedAircraft < MaxAircraftInfinite && isRenderingEnabled();
}
bool CSimulatorCommon::isMaxDistanceRestricted() const
{
return !m_maxRenderedDistance.isNull();
}
void CSimulatorCommon::enableDebugMessages(bool driverMessages, bool interpolatorMessages)
{
this->m_debugMessages = driverMessages;
Q_UNUSED(interpolatorMessages);
}
int CSimulatorCommon::getInstalledModelsCount() const
{
return getInstalledModels().size();
}
void CSimulatorCommon::highlightAircraft(const BlackMisc::Simulation::CSimulatedAircraft &aircraftToHighlight, bool enableHighlight, const BlackMisc::PhysicalQuantities::CTime &displayTime)
{
CCallsign cs(aircraftToHighlight.getCallsign());
this->m_highlightedAircraft.removeByCallsign(cs);
if (enableHighlight)
{
qint64 deltaT = displayTime.valueRounded(CTimeUnit::ms(), 0);
this->m_highlightEndTimeMsEpoch = QDateTime::currentMSecsSinceEpoch() + deltaT;
this->m_highlightedAircraft.push_back(aircraftToHighlight);
}
}
bool CSimulatorCommon::isRenderingEnabled() const
{
if (m_maxRenderedAircraft < 1) { return false; }
if (!isMaxDistanceRestricted()) { return true; }
return m_maxRenderedDistance.valueRounded(CLengthUnit::NM(), 2) > 0.1;
}
bool CSimulatorCommon::isRenderingRestricted() const
{
return this->isMaxDistanceRestricted() || this->isMaxAircraftRestricted();
}
void CSimulatorCommon::deleteAllRenderingRestrictions()
{
if (!isRenderingEnabled()) { return; }
this->m_maxRenderedDistance = CLength(0, CLengthUnit::nullUnit());
this->m_maxRenderedAircraft = MaxAircraftInfinite;
emit restrictedRenderingChanged(false);
}
void CSimulatorCommon::ps_oneSecondTimer()
{
m_timerCounter++;
blinkHighlightedAircraft();
// any <n> seconds
if (m_timerCounter % 10 == 0)
{
recalculateRestrictedAircraft();
}
}
ISimulatorListener::ISimulatorListener(QObject *parent) : QObject(parent)
{ }
const CSimulatorPluginInfo &CSimulatorCommon::getSimulatorPluginInfo() const
{
return m_simulatorPluginInfo;
}
const CSimulatorSetup &CSimulatorCommon::getSimulatorSetup() const
{
return m_simulatorSetup;
}
} // namespace

151
src/blackcore/simulator.h
View File

@@ -34,6 +34,7 @@ namespace BlackCore
class BLACKCORE_EXPORT ISimulator : public QObject
{
Q_OBJECT
public:
//! ISimulator status
enum SimulatorStatus
@@ -80,15 +81,14 @@ namespace BlackCore
//! Disconnect from simulator
virtual bool disconnectFrom() = 0;
//! Add new remote aircraft to the simulator
//! \sa changeRemoteAircraftEnabled to hide a remote aircraft
virtual bool addRemoteAircraft(const BlackMisc::Simulation::CSimulatedAircraft &remoteAircraft) = 0;
//! Logically add a new aircraft. Depending on max. aircraft, enabled status etc.
//! it will physically added to the simulator.
//! \sa physicallyAddRemoteAircraft
virtual bool logicallyAddRemoteAircraft(const BlackMisc::Simulation::CSimulatedAircraft &remoteAircraft) = 0;
//! Remove remote aircraft from simulator
virtual bool removeRemoteAircraft(const BlackMisc::Aviation::CCallsign &callsign) = 0;
//! Remove all remote aircraft
virtual void removeAllRemoteAircraft() = 0;
//! Logically remove remote aircraft from simulator. Depending on max. aircraft, enabled status etc.
//! it will physically added to the simulator.
virtual bool logicallyRemoveRemoteAircraft(const BlackMisc::Aviation::CCallsign &callsign) = 0;
//! Change remote aircraft per property
virtual bool changeRemoteAircraftModel(const BlackMisc::Simulation::CSimulatedAircraft &aircraft, const QString &originator) = 0;
@@ -114,10 +114,10 @@ namespace BlackCore
//! Count of aircraft models for available remote aircrafts
virtual int getInstalledModelsCount() const = 0;
//! Reload the installed models
//! Reload the installed models from disk
virtual void reloadInstalledModels() = 0;
//! Airports in range
//! Airports in range from simulator
virtual BlackMisc::Aviation::CAirportList getAirportsInRange() const = 0;
//! Set time synchronization between simulator and user's computer time
@@ -161,7 +161,12 @@ namespace BlackCore
virtual void enableDebugMessages(bool driver, bool interpolator) = 0;
//! Is the aircraft rendered (displayed in simulator)?
virtual bool isRenderedAircraft(const BlackMisc::Aviation::CCallsign &callsign) const = 0;
//! This shall only return true if the aircraft is really visible in the simulator
virtual bool isPhysicallyRenderedAircraft(const BlackMisc::Aviation::CCallsign &callsign) const = 0;
//! Physically rendered (displayed in simulator)?
//! This shall only return aircraft really visible in the simulator
virtual BlackMisc::Aviation::CCallsignSet physicallyRenderedAircraft() const = 0;
//! Highlight the aircraft for given time (or disable highlight)
virtual void highlightAircraft(const BlackMisc::Simulation::CSimulatedAircraft &aircraftToHighlight, bool enableHighlight, const BlackMisc::PhysicalQuantities::CTime &displayTime) = 0;
@@ -170,13 +175,7 @@ namespace BlackCore
virtual bool isRenderingEnabled() const = 0;
//! Originator
const QString &simulatorOriginator()
{
// string is generated once, the timestamp allows to use multiple
// components (as long as they are not generated at the same ms)
static const QString o = QString("SIMULATOR:").append(QString::number(QDateTime::currentMSecsSinceEpoch()));
return o;
}
const QString &simulatorOriginator();
signals:
//! Simulator combined status
@@ -194,23 +193,20 @@ namespace BlackCore
//! Installed aircraft models ready or changed
void installedAircraftModelsChanged();
protected slots:
//! Provider added situation
virtual void ps_remoteProviderAddAircraftSituation(const BlackMisc::Aviation::CAircraftSituation &situation);
//! Provider added parts
virtual void ps_remoteProvideraddAircraftParts(const BlackMisc::Aviation::CAircraftParts &parts);
//! Provider removed aircraft
virtual void ps_remoteProviderRemovedAircraft(const BlackMisc::Aviation::CCallsign &callsign);
//! Provider aircraft snapshot
virtual void ps_remoteProviderAircraftSnapshot(const BlackMisc::Simulation::CAirspaceAircraftSnapshot &aircraftSnapshot);
protected:
//! Default constructor
ISimulator(QObject *parent = nullptr) : QObject(parent) {}
//! Add new remote aircraft physically to the simulator
//! \sa changeRemoteAircraftEnabled to hide a remote aircraft
virtual bool physicallyAddRemoteAircraft(const BlackMisc::Simulation::CSimulatedAircraft &remoteAircraft) = 0;
//! Remove remote aircraft from simulator
virtual bool physicallyRemoveRemoteAircraft(const BlackMisc::Aviation::CCallsign &callsign) = 0;
//! Remove all remote aircraft
virtual void physicallyRemoveAllRemoteAircraft() = 0;
//! Emit the combined status
//! \sa simulatorStatusChanged;
void emitSimulatorCombinedStatus();
@@ -271,99 +267,6 @@ namespace BlackCore
virtual ISimulatorListener *createListener(QObject *parent = nullptr) = 0;
};
//! Common base class with providers, interface and some base functionality
class BLACKCORE_EXPORT CSimulatorCommon :
public BlackCore::ISimulator,
public BlackMisc::Simulation::COwnAircraftAware, // gain access to in memor own aircraft data
public BlackMisc::Simulation::CRemoteAircraftAware // gain access to in memory remote aircraft data
{
Q_OBJECT
public:
//! \copydoc ISimulator::getMaxRenderedAircraft
virtual int getMaxRenderedAircraft() const override;
//! \copydoc ISimulator::setMaxRenderedAircraft
virtual void setMaxRenderedAircraft(int maxRenderedAircraft) override;
//! \copydoc ISimulator::setMaxRenderedDistance
virtual void setMaxRenderedDistance(BlackMisc::PhysicalQuantities::CLength &distance) override;
//! \copydoc ISimulator::getMaxRenderedDistance
virtual BlackMisc::PhysicalQuantities::CLength getMaxRenderedDistance() const override;
//! \copydoc ISimulator::getRenderedDistanceBoundary
virtual BlackMisc::PhysicalQuantities::CLength getRenderedDistanceBoundary() const override;
//! \copydoc ISimulator::isMaxAircraftRestricted
virtual bool isMaxAircraftRestricted() const override;
//! \copydoc ISimulator::isMaxDistanceRestricted
virtual bool isMaxDistanceRestricted() const override;
//! \copydoc ISimulator::enableDebuggingMessages
virtual void enableDebugMessages(bool driverMessages, bool interpolatorMessages) override;
//! \copydoc ISimulator::getInstalledModelsCount
virtual int getInstalledModelsCount() const override;
//! \copydoc IContextSimulator::highlightAircraft
virtual void highlightAircraft(const BlackMisc::Simulation::CSimulatedAircraft &aircraftToHighlight, bool enableHighlight, const BlackMisc::PhysicalQuantities::CTime &displayTime) override;
//! \copydoc IContextSimulator::isRenderingEnabled
virtual bool isRenderingEnabled() const override;
//! \copydoc IContextSimulator::isRenderingRestricted
virtual bool isRenderingRestricted() const override;
//! \copydoc IContextSimulator::getSimulatorPluginInfo
virtual const BlackMisc::Simulation::CSimulatorPluginInfo &getSimulatorPluginInfo() const override;
//! \copydoc IContextSimulator::getSimulatorSetup
virtual const BlackMisc::Simulation::CSimulatorSetup &getSimulatorSetup() const override;
//! \copydoc IContextSimulator::deleteAllRenderingRestrictions
virtual void deleteAllRenderingRestrictions();
protected slots:
//! Slow timer used to highlight aircraft, can be used for other things too
virtual void ps_oneSecondTimer();
protected:
//! Constructor
CSimulatorCommon(const BlackMisc::Simulation::CSimulatorPluginInfo &info,
BlackMisc::Simulation::IOwnAircraftProvider *ownAircraftProvider,
BlackMisc::Simulation::IRemoteAircraftProvider *remoteAircraftProvider,
QObject *parent = nullptr);
//! Blink the highlighted aircraft
void blinkHighlightedAircraft();
//! Recalculate the restricted aircraft
void recalculateRestrictedAircraft();
//! Restore aircraft from backedn data
void resetAircraftFromBacked(const BlackMisc::Aviation::CCallsign &callsign);
//! Override parts and situation from current interpolator values, if any!
void setInitialAircraftSituationAndParts(BlackMisc::Simulation::CSimulatedAircraft &aircraft) const;
bool m_debugMessages = false; //!< Display debug messages
bool m_blinkCycle = false; //!< use for highlighting
IInterpolator *m_interpolator = nullptr; //!< interpolator instance
qint64 m_highlightEndTimeMsEpoch = 0; //!< end highlighting
int m_timerCounter = 0; //!< allows to calculate n seconds
QTimer *m_oneSecondTimer = nullptr; //!< timer
BlackMisc::Simulation::CSimulatorPluginInfo m_simulatorPluginInfo; //!< info object
BlackMisc::Simulation::CSimulatorSetup m_simulatorSetup; //!< setup object
BlackMisc::Simulation::CSimulatedAircraftList m_highlightedAircraft; //!< all other aircraft are to be ignored
BlackMisc::Aviation::CCallsignSet m_callsignsToBeRendered; //!< callsigns which will be rendered
int m_maxRenderedAircraft = MaxAircraftInfinite; //!< max.rendered aircraft
BlackMisc::PhysicalQuantities::CLength m_maxRenderedDistance { 0.0, BlackMisc::PhysicalQuantities::CLengthUnit::nullUnit()}; //!< max.distance for rendering
};
} // namespace
Q_DECLARE_INTERFACE(BlackCore::ISimulatorFactory, "org.swift-project.blackcore.simulatorinterface")

322
src/blackcore/simulator_common.cpp Normal file
View File

@@ -0,0 +1,322 @@
/* Copyright (C) 2013
* swift Project Community / Contributors
*
* This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
* directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
* including this file, may be copied, modified, propagated, or distributed except according to the terms
* contained in the LICENSE file.
*/
#include "simulator_common.h"
#include "interpolator.h"
#include "blackmisc/logmessage.h"
#include "blackmisc/collection.h"
using namespace BlackMisc;
using namespace BlackMisc::Aviation;
using namespace BlackMisc::Simulation;
using namespace BlackMisc::PhysicalQuantities;
using namespace BlackMisc::Simulation;
namespace BlackCore
{
CSimulatorCommon::CSimulatorCommon(const CSimulatorPluginInfo &info,
BlackMisc::Simulation::IOwnAircraftProvider *ownAircraftProvider,
BlackMisc::Simulation::IRemoteAircraftProvider *remoteAircraftProvider,
QObject *parent)
: ISimulator(parent),
COwnAircraftAware(ownAircraftProvider),
CRemoteAircraftAware(remoteAircraftProvider),
m_simulatorPluginInfo(info)
{
this->setObjectName(info.getIdentifier());
this->m_oneSecondTimer = new QTimer(this);
this->m_oneSecondTimer->setObjectName(this->objectName().append(":m_oneSecondTimer"));
connect(this->m_oneSecondTimer, &QTimer::timeout, this, &CSimulatorCommon::ps_oneSecondTimer);
this->m_oneSecondTimer->start(1000);
// provider signals
bool c = remoteAircraftProvider->connectRemoteAircraftProviderSignals(
std::bind(&CSimulatorCommon::ps_remoteProviderAddAircraftSituation, this, std::placeholders::_1),
std::bind(&CSimulatorCommon::ps_remoteProviderAddAircraftParts, this, std::placeholders::_1),
std::bind(&CSimulatorCommon::ps_remoteProviderRemovedAircraft, this, std::placeholders::_1),
std::bind(&CSimulatorCommon::ps_remoteProviderAircraftSnapshot, this, std::placeholders::_1)
);
Q_ASSERT(c);
Q_UNUSED(c);
// info
CLogMessage(this).info("Initialized simulator driver %1") << m_simulatorPluginInfo.toQString();
}
bool CSimulatorCommon::logicallyAddRemoteAircraft(const CSimulatedAircraft &remoteAircraft)
{
if (!remoteAircraft.isEnabled()) { return false; }
// if not restriced, directly change
if (!isRenderingRestricted()) { return this->physicallyAddRemoteAircraft(remoteAircraft); }
//! \todo Go thru logic
return this->physicallyAddRemoteAircraft(remoteAircraft);
}
bool CSimulatorCommon::logicallyRemoveRemoteAircraft(const CCallsign &callsign)
{
// if not restriced, directly change
if (!isRenderingRestricted()) { return this->physicallyRemoveRemoteAircraft(callsign); }
//! \todo Go thru logic
return this->physicallyRemoveRemoteAircraft(callsign);
}
void CSimulatorCommon::blinkHighlightedAircraft()
{
if (m_highlightedAircraft.isEmpty() || m_highlightEndTimeMsEpoch < 1) { return; }
m_blinkCycle = !m_blinkCycle;
if (QDateTime::currentMSecsSinceEpoch() < m_highlightEndTimeMsEpoch)
{
// blink mode, toggle aircraft
for (const CSimulatedAircraft &aircraft : m_highlightedAircraft)
{
if (m_blinkCycle)
{
this->physicallyRemoveRemoteAircraft(aircraft.getCallsign());
}
else
{
this->physicallyAddRemoteAircraft(aircraft);
}
}
}
else
{
// restore
for (const CSimulatedAircraft &aircraft : m_highlightedAircraft)
{
// get the current state for this aircraft
// it might has been removed in the mean time
const CCallsign cs(aircraft.getCallsign());
resetAircraftFromBacked(cs);
}
m_highlightedAircraft.clear();
m_highlightEndTimeMsEpoch = 0;
}
}
void CSimulatorCommon::recalculateRestrictedAircraft()
{
if (!isMaxAircraftRestricted()) { return; }
if (!isRenderingEnabled()) { return; }
CSimulatedAircraftList newAircraftInRange(getAircraftInRange().getClosestObjects(getMaxRenderedAircraft()));
CCallsignSet newAircraftCallsigns(newAircraftInRange.getCallsigns());
CCallsignSet toBeRemovedCallsigns(m_callsignsToBeRendered.difference(newAircraftCallsigns));
CCallsignSet toBeAddedCallsigns(newAircraftCallsigns.difference(m_callsignsToBeRendered));
for (const CCallsign &cs : toBeRemovedCallsigns)
{
physicallyRemoveRemoteAircraft(cs);
}
for (const CCallsign &cs : toBeAddedCallsigns)
{
physicallyAddRemoteAircraft(newAircraftInRange.findFirstByCallsign(cs));
}
this->m_callsignsToBeRendered = newAircraftCallsigns;
}
void CSimulatorCommon::resetAircraftFromBacked(const CCallsign &callsign)
{
CSimulatedAircraft aircraft(this->getAircraftInRangeForCallsign(callsign));
bool enabled = aircraft.isEnabled();
if (enabled)
{
// are we already visible?
if (!isPhysicallyRenderedAircraft(callsign))
{
this->physicallyAddRemoteAircraft(aircraft);
}
}
else
{
physicallyRemoveRemoteAircraft(callsign);
}
}
void CSimulatorCommon::setInitialAircraftSituationAndParts(CSimulatedAircraft &aircraft) const
{
if (!this->m_interpolator) { return; }
const CCallsign callsign(aircraft.getCallsign());
if (!(this->remoteAircraftSituationsCount(callsign) < 1)) { return; }
// with an interpolator the interpolated situation is used
// to avoid position jittering
qint64 time = QDateTime::currentMSecsSinceEpoch();
IInterpolator::InterpolationStatus is;
CAircraftSituation as(m_interpolator->getInterpolatedSituation(callsign, time, aircraft.isVtol(), is));
if (is.interpolationSucceeded) { aircraft.setSituation(as); }
}
int CSimulatorCommon::getMaxRenderedAircraft() const
{
return (m_maxRenderedAircraft <= MaxAircraftInfinite) ? m_maxRenderedAircraft : MaxAircraftInfinite;
}
void CSimulatorCommon::setMaxRenderedAircraft(int maxRenderedAircraft)
{
if (maxRenderedAircraft == m_maxRenderedAircraft) { return; }
if (maxRenderedAircraft < 1)
{
m_maxRenderedAircraft = 0;
}
else if (maxRenderedAircraft >= MaxAircraftInfinite)
{
m_maxRenderedAircraft = MaxAircraftInfinite;
}
else
{
m_maxRenderedAircraft = maxRenderedAircraft;
}
bool r = isRenderingRestricted();
emit restrictedRenderingChanged(r);
}
void CSimulatorCommon::setMaxRenderedDistance(CLength &distance)
{
if (distance == m_maxRenderedDistance) { return; }
if (distance.isNull() || distance >= getRenderedDistanceBoundary())
{
m_maxRenderedDistance = CLength(0.0, CLengthUnit::nullUnit());
}
else
{
Q_ASSERT(distance.isPositiveWithEpsilonConsidered());
m_maxRenderedDistance = distance;
}
bool r = isRenderingRestricted();
emit restrictedRenderingChanged(r);
}
CLength CSimulatorCommon::getMaxRenderedDistance() const
{
if (m_maxRenderedDistance.isNull()) { return getRenderedDistanceBoundary(); }
return m_maxRenderedDistance;
}
const CSimulatorPluginInfo &CSimulatorCommon::getSimulatorPluginInfo() const
{
return m_simulatorPluginInfo;
}
const CSimulatorSetup &CSimulatorCommon::getSimulatorSetup() const
{
return m_simulatorSetup;
}
CLength CSimulatorCommon::getRenderedDistanceBoundary() const
{
return CLength(20.0, CLengthUnit::NM());
}
bool CSimulatorCommon::isMaxAircraftRestricted() const
{
return m_maxRenderedAircraft < MaxAircraftInfinite && isRenderingEnabled();
}
bool CSimulatorCommon::isMaxDistanceRestricted() const
{
return !m_maxRenderedDistance.isNull();
}
void CSimulatorCommon::enableDebugMessages(bool driverMessages, bool interpolatorMessages)
{
this->m_debugMessages = driverMessages;
Q_UNUSED(interpolatorMessages);
}
int CSimulatorCommon::getInstalledModelsCount() const
{
return getInstalledModels().size();
}
void CSimulatorCommon::highlightAircraft(const BlackMisc::Simulation::CSimulatedAircraft &aircraftToHighlight, bool enableHighlight, const BlackMisc::PhysicalQuantities::CTime &displayTime)
{
CCallsign cs(aircraftToHighlight.getCallsign());
this->m_highlightedAircraft.removeByCallsign(cs);
if (enableHighlight)
{
qint64 deltaT = displayTime.valueRounded(CTimeUnit::ms(), 0);
this->m_highlightEndTimeMsEpoch = QDateTime::currentMSecsSinceEpoch() + deltaT;
this->m_highlightedAircraft.push_back(aircraftToHighlight);
}
}
bool CSimulatorCommon::isRenderingEnabled() const
{
if (m_maxRenderedAircraft < 1) { return false; }
if (!isMaxDistanceRestricted()) { return true; }
return m_maxRenderedDistance.valueRounded(CLengthUnit::NM(), 2) > 0.1;
}
bool CSimulatorCommon::isRenderingRestricted() const
{
return this->isMaxDistanceRestricted() || this->isMaxAircraftRestricted();
}
void CSimulatorCommon::deleteAllRenderingRestrictions()
{
if (!isRenderingEnabled()) { return; }
this->m_maxRenderedDistance = CLength(0, CLengthUnit::nullUnit());
this->m_maxRenderedAircraft = MaxAircraftInfinite;
emit restrictedRenderingChanged(false);
}
void CSimulatorCommon::ps_oneSecondTimer()
{
m_timerCounter++;
blinkHighlightedAircraft();
// any <n> seconds
if (m_timerCounter % 10 == 0)
{
recalculateRestrictedAircraft();
}
}
void CSimulatorCommon::ps_recalculateRenderedAircraft()
{
this->ps_recalculateRenderedAircraft(getLatestAirspaceAircraftSnapshot());
}
void CSimulatorCommon::ps_recalculateRenderedAircraft(const CAirspaceAircraftSnapshot &snapshot)
{
if (!snapshot.isValidSnapshot()) { return;}
CCallsignSet callsignsInSimuator(physicallyRenderedAircraft());
}
void CSimulatorCommon::ps_remoteProviderAddAircraftSituation(const CAircraftSituation &situation)
{
Q_UNUSED(situation);
}
void CSimulatorCommon::ps_remoteProviderAddAircraftParts(const CAircraftParts &parts)
{
Q_UNUSED(parts);
}
void CSimulatorCommon::ps_remoteProviderRemovedAircraft(const CCallsign &callsign)
{
Q_UNUSED(callsign);
}
void CSimulatorCommon::ps_remoteProviderAircraftSnapshot(const CAirspaceAircraftSnapshot &aircraftSnapshot)
{
ps_recalculateRenderedAircraft(aircraftSnapshot);
}
} // namespace

151
src/blackcore/simulator_common.h Normal file
View File

@@ -0,0 +1,151 @@
/* Copyright (C) 2013
* swift Project Community / Contributors
*
* This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
* directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
* including this file, may be copied, modified, propagated, or distributed except according to the terms
* contained in the LICENSE file.
*/
//! \file
#ifndef BLACKCORE_SIMULATOR_COMMON_H
#define BLACKCORE_SIMULATOR_COMMON_H
#include "blackcore/interpolator.h"
#include "blackcore/simulator.h"
#include "blackmisc/simulation/simulatorplugininfo.h"
#include "blackmisc/simulation/simulatorsetup.h"
#include "blackmisc/simulation/simulatedaircraftlist.h"
#include "blackmisc/simulation/aircraftmodellist.h"
#include "blackmisc/simulation/ownaircraftprovider.h"
#include "blackmisc/simulation/remoteaircraftprovider.h"
#include "blackmisc/statusmessagelist.h"
#include "blackmisc/aviation/airportlist.h"
#include "blackmisc/network/textmessage.h"
#include "blackmisc/network/client.h"
#include "blackmisc/pixmap.h"
#include <QObject>
namespace BlackCore
{
//! Common base class with providers, interface and some base functionality
class CSimulatorCommon :
public BlackCore::ISimulator,
public BlackMisc::Simulation::COwnAircraftAware, // gain access to in memor own aircraft data
public BlackMisc::Simulation::CRemoteAircraftAware // gain access to in memory remote aircraft data
{
Q_OBJECT
public:
//! \copydoc ISimulator::getMaxRenderedAircraft
virtual int getMaxRenderedAircraft() const override;
//! \copydoc ISimulator::setMaxRenderedAircraft
virtual void setMaxRenderedAircraft(int maxRenderedAircraft) override;
//! \copydoc ISimulator::setMaxRenderedDistance
virtual void setMaxRenderedDistance(BlackMisc::PhysicalQuantities::CLength &distance) override;
//! \copydoc ISimulator::getMaxRenderedDistance
virtual BlackMisc::PhysicalQuantities::CLength getMaxRenderedDistance() const override;
//! \copydoc ISimulator::getRenderedDistanceBoundary
virtual BlackMisc::PhysicalQuantities::CLength getRenderedDistanceBoundary() const override;
//! \copydoc ISimulator::isMaxAircraftRestricted
virtual bool isMaxAircraftRestricted() const override;
//! \copydoc ISimulator::isMaxDistanceRestricted
virtual bool isMaxDistanceRestricted() const override;
//! \copydoc ISimulator::enableDebuggingMessages
virtual void enableDebugMessages(bool driverMessages, bool interpolatorMessages) override;
//! \copydoc ISimulator::getInstalledModelsCount
virtual int getInstalledModelsCount() const override;
//! \copydoc IContextSimulator::highlightAircraft
virtual void highlightAircraft(const BlackMisc::Simulation::CSimulatedAircraft &aircraftToHighlight, bool enableHighlight, const BlackMisc::PhysicalQuantities::CTime &displayTime) override;
//! \copydoc IContextSimulator::isRenderingEnabled
virtual bool isRenderingEnabled() const override;
//! \copydoc IContextSimulator::isRenderingRestricted
virtual bool isRenderingRestricted() const override;
//! \copydoc IContextSimulator::getSimulatorPluginInfo
virtual const BlackMisc::Simulation::CSimulatorPluginInfo &getSimulatorPluginInfo() const override;
//! \copydoc IContextSimulator::getSimulatorSetup
virtual const BlackMisc::Simulation::CSimulatorSetup &getSimulatorSetup() const override;
//! \copydoc IContextSimulator::deleteAllRenderingRestrictions
virtual void deleteAllRenderingRestrictions();
protected slots:
//! Slow timer used to highlight aircraft, can be used for other things too
virtual void ps_oneSecondTimer();
//! Recalculate the rendered aircraft
virtual void ps_recalculateRenderedAircraft();
//! Recalculate the rendered aircraft
virtual void ps_recalculateRenderedAircraft(const BlackMisc::Simulation::CAirspaceAircraftSnapshot &snapshot);
//! Provider added situation
virtual void ps_remoteProviderAddAircraftSituation(const BlackMisc::Aviation::CAircraftSituation &situation);
//! Provider added parts
virtual void ps_remoteProviderAddAircraftParts(const BlackMisc::Aviation::CAircraftParts &parts);
//! Provider removed aircraft
virtual void ps_remoteProviderRemovedAircraft(const BlackMisc::Aviation::CCallsign &callsign);
//! Provider aircraft snapshot
virtual void ps_remoteProviderAircraftSnapshot(const BlackMisc::Simulation::CAirspaceAircraftSnapshot &aircraftSnapshot);
protected:
//! Constructor
CSimulatorCommon(const BlackMisc::Simulation::CSimulatorPluginInfo &info,
BlackMisc::Simulation::IOwnAircraftProvider *ownAircraftProvider,
BlackMisc::Simulation::IRemoteAircraftProvider *remoteAircraftProvider,
QObject *parent = nullptr);
//! \copydoc IContextSimulator::logicallyAddRemoteAircraft
virtual bool logicallyAddRemoteAircraft(const BlackMisc::Simulation::CSimulatedAircraft &remoteAircraft) override;
//! \copydoc IContextSimulator::logicallyRemoveRemoteAircraft
virtual bool logicallyRemoveRemoteAircraft(const BlackMisc::Aviation::CCallsign &callsign) override;
//! Blink the highlighted aircraft
void blinkHighlightedAircraft();
//! Recalculate the restricted aircraft
void recalculateRestrictedAircraft();
//! Restore aircraft from backedn data
void resetAircraftFromBacked(const BlackMisc::Aviation::CCallsign &callsign);
//! Override parts and situation from current interpolator values, if any!
void setInitialAircraftSituationAndParts(BlackMisc::Simulation::CSimulatedAircraft &aircraft) const;
bool m_debugMessages = false; //!< Display debug messages
bool m_blinkCycle = false; //!< use for highlighting
IInterpolator *m_interpolator = nullptr; //!< interpolator instance
qint64 m_highlightEndTimeMsEpoch = 0; //!< end highlighting
int m_timerCounter = 0; //!< allows to calculate n seconds
QTimer *m_oneSecondTimer = nullptr; //!< timer
BlackMisc::Simulation::CSimulatorPluginInfo m_simulatorPluginInfo; //!< info object
BlackMisc::Simulation::CSimulatorSetup m_simulatorSetup; //!< setup object
BlackMisc::Simulation::CSimulatedAircraftList m_highlightedAircraft; //!< all other aircraft are to be ignored
BlackMisc::Aviation::CCallsignSet m_callsignsToBeRendered; //!< callsigns which will be rendered
int m_maxRenderedAircraft = MaxAircraftInfinite; //!< max.rendered aircraft
BlackMisc::PhysicalQuantities::CLength m_maxRenderedDistance { 0.0, BlackMisc::PhysicalQuantities::CLengthUnit::nullUnit()}; //!< max.distance for rendering
};
} // namespace
#endif // guard