qgschunkedentity_p.h

Go to the documentation of this file.

/***************************************************************************
  qgschunkedentity_p.h
  --------------------------------------
  Date                 : July 2017
  Copyright            : (C) 2017 by Martin Dobias
  Email                : wonder dot sk at gmail dot 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; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSCHUNKEDENTITY_P_H
#define QGSCHUNKEDENTITY_P_H
 
 
//
//  W A R N I N G
//  -------------
//
// This file is not part of the QGIS API.  It exists purely as an
// implementation detail.  This header file may change from version to
// version without notice, or even be removed.
//
 
#include <Qt3DCore/QEntity>
#include <numeric>
 
#define SIP_NO_FILE
 
class QgsAABB;
class QgsChunkNode;
class QgsChunkList;
class QgsChunkQueueJob;
class QgsChunkLoaderFactory;
class QgsChunkBoundsEntity;
class QgsChunkQueueJobFactory;
 
#include <QVector3D>
#include <QMatrix4x4>
 
#include <QTime>
 
#include "qgsfeatureid.h"
#include "qgschunknode_p.h"
 
namespace Qt3DRender
{
  class QPickEvent;
}
 
class QgsChunkedEntity : public Qt3DCore::QEntity
{
    Q_OBJECT
  public:
    QgsChunkedEntity( float tau, QgsChunkLoaderFactory *loaderFactory, bool ownsFactory,
                      int primitivesBudget = std::numeric_limits<int>::max(),
                      Qt3DCore::QNode *parent = nullptr );
    ~QgsChunkedEntity() override;
 
    struct SceneState
    {
      QVector3D cameraPos;   
      float cameraFov;       
      int screenSizePx;      
      QMatrix4x4 viewProjectionMatrix; 
    };
 
    void update( const SceneState &state );
 
    bool needsUpdate() const { return mNeedsUpdate; }
 
    void setShowBoundingBoxes( bool enabled );
 
    void updateNodes( const QList<QgsChunkNode *> &nodes, QgsChunkQueueJobFactory *updateJobFactory );
 
    QList<QgsChunkNode *> activeNodes() const { return mActiveNodes; }
    QgsChunkNode *rootNode() const { return mRootNode; }
 
    int pendingJobsCount() const;
 
    void setPickingEnabled( bool enabled );
    bool hasPickingEnabled() const { return mPickingEnabled; }
 
    void setUsingAdditiveStrategy( bool additive ) { mAdditiveStrategy = additive; }
 
    bool usingAditiveStrategy() const { return mAdditiveStrategy; }
 
    void setGpuMemoryLimit( double gpuMemoryLimit ) { mGpuMemoryLimit = gpuMemoryLimit; }
 
    double gpuMemoryLimit() const { return mGpuMemoryLimit; }
 
    static double calculateEntityGpuMemorySize( Qt3DCore::QEntity *entity );
 
  protected:
    void cancelActiveJob( QgsChunkQueueJob *job );
    void cancelActiveJobs();
    void setNeedsUpdate( bool needsUpdate ) { mNeedsUpdate = needsUpdate; }
 
  private:
    void update( QgsChunkNode *node, const SceneState &state );
 
    void pruneLoaderQueue( const SceneState &state );
 
    void requestResidency( QgsChunkNode *node );
 
    void startJobs();
    QgsChunkQueueJob *startJob( QgsChunkNode *node );
 
  private slots:
    void onActiveJobFinished();
 
    void onPickEvent( Qt3DRender::QPickEvent *event );
 
  signals:
    void pendingJobsCountChanged();
 
    void newEntityCreated( Qt3DCore::QEntity *entity );
 
    void pickedObject( Qt3DRender::QPickEvent *pickEvent, QgsFeatureId fid );
 
  protected:
    QgsChunkNode *mRootNode = nullptr;
    bool mNeedsUpdate = false;
 
    float mTau;
    QgsChunkLoaderFactory *mChunkLoaderFactory = nullptr;
    bool mOwnsFactory = true;
    QgsChunkList *mChunkLoaderQueue = nullptr;
    QgsChunkList *mReplacementQueue = nullptr;
    QList<QgsChunkNode *> mActiveNodes;
    int mFrustumCulled = 0;
 
    // TODO: max. length for loading queue
 
    QTime mCurrentTime;
 
    QgsChunkBoundsEntity *mBboxesEntity = nullptr;
 
    QList<QgsChunkQueueJob *> mActiveJobs;
 
    bool mPickingEnabled = false;
 
    bool mAdditiveStrategy = false;
 
    bool mIsValid = true;
 
    int mPrimitivesBudget = std::numeric_limits<int>::max();
    double mGpuMemoryLimit = 500.0; // in megabytes
};
 
 
#endif // QGSCHUNKEDENTITY_P_H