You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
625 lines
16 KiB
625 lines
16 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2022-2023 Jon Beniston, M7RCE <jon@beniston.com> // |
|
// // |
|
// This program is free software; you can redistribute it and/or modify // |
|
// it under the terms of the GNU General Public License as published by // |
|
// the Free Software Foundation as version 3 of the License, or // |
|
// (at your option) any later version. // |
|
// // |
|
// This program is distributed in the hope that it will be useful, // |
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of // |
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // |
|
// GNU General Public License V3 for more details. // |
|
// // |
|
// You should have received a copy of the GNU General Public License // |
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include <QJsonObject> |
|
|
|
#include "cesiuminterface.h" |
|
#include "util/profiler.h" |
|
|
|
CesiumInterface::CesiumInterface(const MapSettings *settings, QObject *parent) : |
|
MapWebSocketServer(parent), |
|
m_czml(settings) |
|
{ |
|
} |
|
|
|
// Set the view displayed when the Home button is pressed |
|
// Angle in degrees of longitude or latitude either side of central location |
|
void CesiumInterface::setHomeView(float latitude, float longitude, float angle) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setHomeView"}, |
|
{"latitude", latitude}, |
|
{"longitude", longitude}, |
|
{"angle", angle} |
|
}; |
|
send(obj); |
|
} |
|
|
|
// Set the current camera view to a given location |
|
void CesiumInterface::setView(float latitude, float longitude, float altitude) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setView"}, |
|
{"latitude", latitude}, |
|
{"longitude", longitude}, |
|
{"altitude", altitude} |
|
}; |
|
send(obj); |
|
} |
|
|
|
// How the camera follows the tracked object: MapSettings::CameraMode |
|
void CesiumInterface::setCameraMode(int mode) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setCameraMode"}, |
|
{"mode", mode} |
|
}; |
|
send(obj); |
|
} |
|
|
|
// Play glTF model animation for the map item with the specified name |
|
void CesiumInterface::playAnimation(const QString &name, Animation *animation) |
|
{ |
|
QJsonObject obj { |
|
{"command", "playAnimation"}, |
|
{"id", name}, |
|
{"animation", animation->m_name}, |
|
{"startDateTime", animation->m_startDateTime}, |
|
{"reverse", animation->m_reverse}, |
|
{"loop", animation->m_loop}, |
|
{"stop", animation->m_stop}, |
|
{"startOffset", animation->m_startOffset}, |
|
{"duration", animation->m_duration}, |
|
{"multiplier", animation->m_multiplier}, |
|
{"sound", animation->m_sound} |
|
}; |
|
if (m_batching) { |
|
// Queued so it cannot overtake the entity update it refers to |
|
m_pendingCommands.append(obj); |
|
return; |
|
} |
|
send(obj); |
|
} |
|
|
|
// Set date and time for the map |
|
void CesiumInterface::setDateTime(QDateTime dateTime) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setDateTime"}, |
|
{"dateTime", dateTime.toString(Qt::ISODate)} |
|
}; |
|
send(obj); |
|
} |
|
|
|
// Get current date and time from the map |
|
void CesiumInterface::getDateTime() |
|
{ |
|
QJsonObject obj { |
|
{"command", "getDateTime"} |
|
}; |
|
send(obj); |
|
} |
|
|
|
// Set the camera to track the map item with the specified name |
|
void CesiumInterface::track(const QString& name) |
|
{ |
|
QJsonObject obj { |
|
{"command", "trackId"}, |
|
{"id", name} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::setDefaultImagery(const QString &imagery) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setDefaultImagery"}, |
|
{"imagery", imagery} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::setTerrain(const QString &terrain, const QString &maptilerAPIKey, bool lighting, bool water) |
|
{ |
|
QString provider; |
|
QString url; |
|
if (terrain == "Maptiler") |
|
{ |
|
provider = "CesiumTerrainProvider"; |
|
url = "https://api.maptiler.com/tiles/terrain-quantized-mesh/?key=" + maptilerAPIKey; |
|
} |
|
else if (terrain == "ArcGIS") |
|
{ |
|
provider = "ArcGISTiledElevationTerrainProvider"; |
|
url = "https://elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer"; |
|
} |
|
else |
|
{ |
|
provider = terrain; |
|
} |
|
QJsonObject obj { |
|
{"command", "setTerrain"}, |
|
{"provider", provider}, |
|
{"url", url}, |
|
// Not "lighting", which is the Sun/camera lighting in setLighting |
|
{"terrainLighting", lighting}, |
|
{"water", water} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::setBuildings(const QString &buildings) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setBuildings"}, |
|
{"buildings", buildings} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::setGooglePhotorealistic3DTiles(bool enabled) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setGooglePhotorealistic3DTiles"}, |
|
{"enabled", enabled} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::setLighting(bool useSunLight, float cameraLightIntensity, float distantLightIntensity) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setLighting"}, |
|
{"useSunLight", useSunLight}, |
|
{"cameraLightIntensity", cameraLightIntensity}, |
|
{"distantLightIntensity", distantLightIntensity} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::setLowDetailModels(bool enabled) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setLowDetailModels"}, |
|
{"enabled", enabled} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::setCameraReferenceFrame(bool eci) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setCameraReferenceFrame"}, |
|
{"eci", eci} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::setAntiAliasing(bool fxaa, int msaa) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setAntiAliasing"}, |
|
{"fxaa", fxaa}, |
|
{"msaa", msaa} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::setHDR(bool enabled) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setHDR"}, |
|
{"hdr", enabled} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::setFog(bool enabled) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setFog"}, |
|
{"fog", enabled} |
|
}; |
|
send(obj); |
|
} |
|
|
|
// 0 means render at the refresh rate of the display the map is on, which the page |
|
// cannot determine for itself |
|
void CesiumInterface::setFrameRate(int frameRate) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setFrameRate"}, |
|
{"frameRate", frameRate} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::showFPS(bool show) |
|
{ |
|
QJsonObject obj { |
|
{"command", "showFPS"}, |
|
{"show", show} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::showPFD(bool show) |
|
{ |
|
QJsonObject obj { |
|
{"command", "showPFD"}, |
|
{"show", show} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::showND(bool show) |
|
{ |
|
QJsonObject obj { |
|
{"command", "showND"}, |
|
{"show", show} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::showEFIS(bool show) |
|
{ |
|
QJsonObject obj { |
|
{"command", "showEFIS"}, |
|
{"show", show} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::showRMP(bool show) |
|
{ |
|
QJsonObject obj { |
|
{"command", "showRMP"}, |
|
{"show", show} |
|
}; |
|
send(obj); |
|
} |
|
|
|
// The RMP's two VHF channels: {"vhf1": {"active": Hz, "standby": Hz, "available": bool}, |
|
// "vhf2": {...}}. active is null when the linked AM Demod cannot be read |
|
void CesiumInterface::setRMPState(const QJsonObject& state) |
|
{ |
|
QJsonObject obj = state; |
|
obj.insert("command", "setRMPState"); |
|
send(obj); |
|
} |
|
|
|
// Hiding also suppresses the DCDU's pop-on-message behaviour |
|
void CesiumInterface::showDCDU(bool show) |
|
{ |
|
QJsonObject obj { |
|
{"command", "showDCDU"}, |
|
{"show", show} |
|
}; |
|
send(obj); |
|
} |
|
|
|
// The airport database for the ND's airport overlay: [{n, lat, lon, t}] with |
|
// t 0 small, 1 medium, 2 large |
|
// Where each cockpit panel is to be placed: {"pfd": {"l": x, "t": y, "w": w, "h": h}, ...} |
|
// in CSS pixels, as the page last reported them |
|
void CesiumInterface::setPanelGeometry(const QJsonObject& panels) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setPanelGeometry"}, |
|
{"panels", panels} |
|
}; |
|
send(obj); |
|
} |
|
|
|
// What the EFIS knobs and pushbuttons are set to: {"mode", "range", "wx", "terr", |
|
// "arpt", "vor", "tcas"}, as the page last reported them |
|
void CesiumInterface::setEFISState(const QJsonObject& state) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setEFISState"}, |
|
{"state", state} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::setNDAirports(const QJsonArray& airports) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setNDAirports"}, |
|
{"airports", airports} |
|
}; |
|
send(obj); |
|
} |
|
|
|
// The VOR-family navaids for the ND's overlay: [{n, lat, lon}] |
|
void CesiumInterface::setNDNavAids(const QJsonArray& navAids) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setNDNavAids"}, |
|
{"navAids", navAids} |
|
}; |
|
send(obj); |
|
} |
|
|
|
// Volumes are [0..100] |
|
void CesiumInterface::setAudioVolume(int mapItemVolume, int cockpitVolume) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setAudioVolume"}, |
|
{"mapItem", mapItemVolume / 100.0}, |
|
{"cockpit", cockpitVolume / 100.0} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::showMUF(bool show) |
|
{ |
|
QJsonObject obj { |
|
{"command", "showMUF"}, |
|
{"show", show} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::showfoF2(bool show) |
|
{ |
|
QJsonObject obj { |
|
{"command", "showfoF2"}, |
|
{"show", show} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::showMagDec(bool show) |
|
{ |
|
QJsonObject obj { |
|
{"command", "showMagneticDeclination"}, |
|
{"show", show} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::showMaidenheadGrid(bool show) |
|
{ |
|
QJsonObject obj { |
|
{"command", "showMaidenheadGrid"}, |
|
{"show", show} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::showLayer(const QString& layer, bool show) |
|
{ |
|
QJsonObject obj { |
|
{"command", "showLayer"}, |
|
{"layer", layer}, |
|
{"show", show} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::setLayerSettings(const QString& layer, const QStringList& settings, const QList<QVariant>& values) |
|
{ |
|
QJsonObject obj { |
|
{"command", "setLayerSettings"}, |
|
{"layer", layer}, |
|
}; |
|
for (int i = 0; i < settings.size(); i++) { |
|
obj.insert(settings[i], QJsonValue::fromVariant(values[i])); |
|
} |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::updateImage(const QString &name, float east, float west, float north, float south, float altitude, const QString &data) |
|
{ |
|
QJsonObject obj { |
|
{"command", "updateImage"}, |
|
{"name", name}, |
|
{"east", east}, |
|
{"west", west}, |
|
{"north", north}, |
|
{"south", south}, |
|
{"altitude", altitude}, |
|
{"data", data}, |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::removeImage(const QString &name) |
|
{ |
|
QJsonObject obj { |
|
{"command", "removeImage"}, |
|
{"name", name} |
|
}; |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::removeAllImages() |
|
{ |
|
QJsonObject obj { |
|
{"command", "removeAllImages"} |
|
}; |
|
send(obj); |
|
} |
|
|
|
// Remove all entities created by CZML |
|
void CesiumInterface::removeAllCZMLEntities() |
|
{ |
|
QJsonObject obj { |
|
{"command", "removeAllCZMLEntities"} |
|
}; |
|
send(obj); |
|
// Cesium keeps nothing after this, so neither may we: describing an item against |
|
// what it used to look like would leave out of the packet everything that has not |
|
// changed, and none of it is there any more |
|
m_czml.clear(); |
|
} |
|
|
|
void CesiumInterface::initCZML() |
|
{ |
|
QJsonObject obj = m_czml.init(); |
|
czml(obj); |
|
} |
|
|
|
// Send and process CZML |
|
void CesiumInterface::czml(QJsonObject &obj) |
|
{ |
|
if (m_batching) |
|
{ |
|
// The command key is added once, to the array, not to every packet |
|
m_batch.append(obj); |
|
return; |
|
} |
|
obj.insert("command", "czml"); |
|
send(obj); |
|
} |
|
|
|
void CesiumInterface::beginBatch() |
|
{ |
|
m_batching = true; |
|
m_batch = QJsonArray(); |
|
} |
|
|
|
void CesiumInterface::endBatch() |
|
{ |
|
m_batching = false; |
|
|
|
// One packet is not worth an array |
|
if (m_batch.size() == 1) |
|
{ |
|
QJsonObject obj = m_batch.first().toObject(); |
|
obj.insert("command", "czml"); |
|
m_sendQueue.append(obj); |
|
} |
|
else if (!m_batch.isEmpty()) |
|
{ |
|
// Cut into chunks so the page pays for the flush over several frames rather than |
|
// one - see m_batchChunkPackets |
|
for (qsizetype i = 0; i < m_batch.size(); i += m_batchChunkPackets) |
|
{ |
|
qsizetype count = m_batch.size() - i; |
|
QJsonArray chunk; |
|
|
|
if (count > m_batchChunkPackets) { |
|
count = m_batchChunkPackets; |
|
} |
|
for (qsizetype j = 0; j < count; j++) { |
|
chunk.append(m_batch.at(i + j)); |
|
} |
|
m_sendQueue.append(QJsonObject { |
|
{"command", "czmlArray"}, |
|
{"packets", chunk} |
|
}); |
|
} |
|
} |
|
m_batch = QJsonArray(); |
|
|
|
// The CZML goes first, then anything that was issued while it was being collected - |
|
// an animation must not arrive before the entity update it belongs to. Queued behind |
|
// the chunks rather than sent here, which also keeps them behind the chunks of an |
|
// earlier batch that has not finished draining |
|
m_sendQueue.append(m_pendingCommands); |
|
m_pendingCommands.clear(); |
|
|
|
drainSendQueue(); |
|
} |
|
|
|
// Sends one chunk and the commands that follow it, then leaves the rest to the timer. The |
|
// commands go with their chunk rather than one per tick: they are small, and holding them |
|
// back would only delay the animation behind the entity update it belongs to. |
|
void CesiumInterface::drainSendQueue() |
|
{ |
|
// Decided once, before anything is sent, so a drain that starts backlogged empties the |
|
// whole queue instead of stopping as soon as it drops under the limit |
|
const bool backlogged = m_sendQueue.size() > m_batchMaxQueuedMessages; |
|
bool sentChunk = false; |
|
|
|
while (!m_sendQueue.isEmpty()) |
|
{ |
|
const QJsonObject obj = m_sendQueue.first(); |
|
const QString command = obj.value("command").toString(); |
|
const bool isCZML = (command == "czmlArray") || (command == "czml"); |
|
|
|
if (isCZML && sentChunk && !backlogged) { |
|
break; |
|
} |
|
m_sendQueue.removeFirst(); |
|
send(obj); |
|
sentChunk = sentChunk || isCZML; |
|
} |
|
|
|
if (m_sendQueue.isEmpty()) |
|
{ |
|
if (m_chunkTimer) { |
|
m_chunkTimer->stop(); |
|
} |
|
return; |
|
} |
|
if (!m_chunkTimer) |
|
{ |
|
m_chunkTimer = new QTimer(this); |
|
QObject::connect(m_chunkTimer, &QTimer::timeout, this, [this]() { drainSendQueue(); }); |
|
} |
|
if (!m_chunkTimer->isActive()) { |
|
m_chunkTimer->start(m_batchChunkIntervalMS); |
|
} |
|
} |
|
|
|
void CesiumInterface::update(ObjectMapItem *mapItem, bool isTarget, bool isSelected) |
|
{ |
|
PROFILER_START() |
|
// Track segments first: update() resets the item's cached state when the item is |
|
// deleted, and the segments' cleanup packets are built from that state |
|
const QList<QJsonObject> trackSegments = m_czml.updateTrackSegments3D(mapItem, isSelected); |
|
PROFILER_STOP("Map CZML segments") |
|
PROFILER_RESTART() |
|
QJsonObject obj = m_czml.update(mapItem, isTarget, isSelected); |
|
PROFILER_STOP("Map CZML update") |
|
PROFILER_RESTART() |
|
// Nothing changed: the packet holds an id and nothing else, so there is nothing for |
|
// Cesium to do with it. Sending it anyway costs a websocket frame, a JSON parse and a |
|
// czmlStream.process() call in the page, per item - which with 200,000 static items |
|
// in the model was most of the traffic the 3D map ever saw. |
|
if (obj.size() > 1) { |
|
czml(obj); |
|
} |
|
for (QJsonObject segment : trackSegments) { // czml() takes a non-const reference |
|
czml(segment); |
|
} |
|
PROFILER_STOP("Map CZML emit") |
|
} |
|
|
|
void CesiumInterface::update(PolygonMapItem *mapItem) |
|
{ |
|
QJsonObject obj = m_czml.update(mapItem); |
|
if (obj.size() > 1) { // id only means nothing to do - see update(ObjectMapItem *) |
|
czml(obj); |
|
} |
|
} |
|
|
|
void CesiumInterface::update(PolylineMapItem *mapItem) |
|
{ |
|
QJsonObject obj = m_czml.update(mapItem); |
|
if (obj.size() > 1) { // id only means nothing to do - see update(ObjectMapItem *) |
|
czml(obj); |
|
} |
|
} |
|
|
|
void CesiumInterface::setPosition(const QGeoCoordinate& position) |
|
{ |
|
m_czml.setPosition(position); |
|
} |
|
|
|
void CesiumInterface::save(const QString& filename, const QString& dataDir) |
|
{ |
|
QJsonObject obj { |
|
{"command", "save"}, |
|
{"filename", filename}, |
|
{"dataDir", dataDir} |
|
}; |
|
send(obj); |
|
}
|
|
|