SurfaceModel.h

Go to the documentation of this file.

/****************************************************************************
 *
 * (c) 2009-2024 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
 *
 * QGroundControl is licensed according to the terms in the file
 * COPYING.md in the root of the source code directory.
 *
 ****************************************************************************/
 
#pragma once
 
#include <optional>
 
#include <QtCore/QElapsedTimer>
#include <QtCore/QHash>
#include <QtCore/QList>
#include <QtCore/QObject>
#include <QtCore/QPointF>
#include <QtCore/QRectF>
#include <QtCore/QSet>
#include <QtCore/QVarLengthArray>
 
#include "TileMath.h"
 
class GeoMapCamera;
class HeightField;
class HeightSource;
 
class SurfaceModel : public QObject
{
    Q_OBJECT
 
public:
    SurfaceModel(GeoMapCamera* camera, HeightSource* heightSource, HeightField* field, QObject* parent = nullptr);
 
    static constexpr int kGridSize = 16;  
    static constexpr int kMaxPatches = 256;
    static constexpr int kMaxPatchAddsPerUpdate = 2;
    static constexpr int kMaxPatchRemovalsPerUpdate = 4;
    static constexpr double kRefinePixelThreshold = 384.0;  
    static constexpr double kMaxRangeMultiplier = 40.0;     
    static constexpr int kVisibleSampleGrid = 5;            
    static constexpr double kRecullHeightMargin = 25.0;
 
    struct Patch
    {
        TileMath::TileKey key;
        QList<float> heights;  
        bool ready = true;
        bool covered = false;  
        float edgeStep = 0.0f;   
        QPointF edgeStepAt;      
        bool edgeCliff = false;  
    };
 
    void update();
 
    bool updateSettled() const { return !_updatePending && !_addsDeferred && !_removalsDeferred; }
 
    QList<Patch> patches() const;
 
    std::optional<Patch> patch(const TileMath::TileKey& key) const;
 
    std::optional<double> renderedHeightAt(const QPointF& world) const;
 
    QList<int> edgeLodDeltas(const TileMath::TileKey& key) const;
 
    struct UpdateStats
    {
        int updates = 0;
        qint64 totalUs = 0;
        qint64 maxUs = 0;
        qint64 addTotalUs = 0;  
        qint64 addMaxUs = 0;
    };
 
    UpdateStats takeUpdateStats();
 
    QRectF visibleGroundRect() const { return _visibleGroundRect(_maxTerrainZ()); }
 
    int patchCount() const { return _patches.count(); }
 
    int pendingCount() const { return 0; }
 
#ifdef QGC_UNITTEST_BUILD
    void drainUpdates()
    {
        int guard = kMaxPatches;
        do {
            update();
        } while ((_addsDeferred || _removalsDeferred) && (--guard > 0));
    }
#endif
 
signals:
    void patchAdded(const TileMath::TileKey& key);
    void patchMeshChanged(const TileMath::TileKey& key);
    void patchEdgeDeltasChanged(const TileMath::TileKey& key);
    void patchRemoved(const TileMath::TileKey& key);
    void surfaceHeightsChanged();
 
private slots:
    void _fieldRegionChanged(const QRectF& worldRect);
 
private:
    struct PatchData
    {
        QList<float> heights;      
        float maxHeight = 0.0f;    
        qint64 cliffSinceMs = -1;  
        float edgeStep = 0.0f;     
        QPointF edgeStepAt;
        bool edgeCliff = false;
    };
 
    static constexpr double kCliffLogSlope = 0.5;
 
    void _samplePatch(const TileMath::TileKey& key, PatchData& data);
 
    double _projectedPixels(const TileMath::TileKey& key, const QPointF& cameraGround, double cameraHeight) const;
    QList<TileMath::TileKey> _desiredPatches(const QRectF& visible, const QPointF& cameraGround,
                                             double cameraHeight) const;
    QRectF _visibleGroundRect(double terrainZ) const;
    double _maxTerrainZ() const;
    int _edgeDelta(const TileMath::TileKey& key, int dx, int dy) const;
    void _scheduleUpdate();
 
    // update() phases (see update() for the pass structure)
    struct AddResult
    {
        int adds = 0;
        qint64 addUs = 0;
    };
 
    AddResult _addDesiredPatches(const QList<TileMath::TileKey>& desired, QVarLengthArray<QRectF, 8>& churnRects);
    int _removeStalePatches(const QList<TileMath::TileKey>& desired, const QSet<TileMath::TileKey>& desiredSet,
                            QVarLengthArray<QRectF, 8>& churnRects);
    void _notifyEdgeChurn(const QVarLengthArray<QRectF, 8>& churnRects);
    void _repinAncestors();
 
    GeoMapCamera* const _camera;
    HeightSource* const _heightSource;
    HeightField* const _field;
    QHash<TileMath::TileKey, PatchData> _patches;
    UpdateStats _updateStats;
    bool _updatePending = false;     
    bool _addsDeferred = false;      
    bool _removalsDeferred = false;  
    double _culledTerrainZ = 0.0;    
    QElapsedTimer _cliffClock;
};