qgschunknode_p.h

Go to the documentation of this file.

/***************************************************************************
  qgschunknode_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 QGSCHUNKNODE_P_H
#define QGSCHUNKNODE_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 "qgsaabb.h"
 
#include "qgis.h"
#include <QTime>
 
#define SIP_NO_FILE
 
namespace Qt3DCore
{
  class QEntity;
}
 
struct QgsChunkListEntry;
class QgsChunkLoader;
class QgsChunkQueueJob;
class QgsChunkQueueJobFactory;
 
 
struct QgsChunkNodeId
{
 
  QgsChunkNodeId( int _d = -1, int _x = -1, int _y = -1, int _z = -1 )
    : d( _d ), x( _x ), y( _y ), z( _z ) {}
 
  QgsChunkNodeId( long long id )
    : uniqueId( id )
  {}
 
  int d = 0;
  int x = 0;
  int y = 0;
  int z = 0;
  long long uniqueId = -1;
 
  QString text() const
  {
    if ( uniqueId != -1 )
      return QString::number( uniqueId );
    else if ( z == -1 )
      return QStringLiteral( "%1/%2/%3" ).arg( d ).arg( x ).arg( y );   // quadtree
    else
      return QStringLiteral( "%1/%2/%3/%4" ).arg( d ).arg( x ).arg( y ).arg( z );   // octree
  }
 
  bool operator==( const QgsChunkNodeId &other ) const
  {
    return ( uniqueId == -1 && other.uniqueId == -1 && d == other.d && x == other.x && y == other.y && z == other.z )
           || ( uniqueId != -1 && uniqueId == other.uniqueId );
  }
 
  bool operator!=( const QgsChunkNodeId &other ) const
  {
    return !( *this == other );
  }
};
 
class QgsChunkNode
{
  public:
 
    QgsChunkNode( const QgsChunkNodeId &nodeId, const QgsAABB &bbox, float error, QgsChunkNode *parent = nullptr );
 
    ~QgsChunkNode();
 
    enum State
    {
      Skeleton,         
      QueuedForLoad,    
      Loading,          
      Loaded,           
      QueuedForUpdate,  
      Updating,         
    };
 
    QgsAABB bbox() const { return mBbox; }
    float error() const { return mError; }
    QgsChunkNodeId tileId() const { return mNodeId; }
    QgsChunkNode *parent() const { return mParent; }
    int childCount() const { return mChildren.count(); }
    QgsChunkNode *const *children() const { return mChildren.constData(); }
    Qgis::TileRefinementProcess refinementProcess() const { return mRefinementProcess; }
    State state() const { return mState; }
 
    QgsChunkListEntry *loaderQueueEntry() const { return mLoaderQueueEntry; }
    QgsChunkListEntry *replacementQueueEntry() const { return mReplacementQueueEntry; }
    QgsChunkLoader *loader() const { return mLoader; }
    Qt3DCore::QEntity *entity() const { return mEntity; }
    QgsChunkQueueJob *updater() const { return mUpdater; }
 
    bool allChildChunksResident( QTime currentTime ) const;
 
    bool hasChildrenPopulated() const { return mChildrenPopulated; }
 
    void populateChildren( const QVector<QgsChunkNode *> &children );
 
    void setRefinementProcess( Qgis::TileRefinementProcess refinementProcess ) { mRefinementProcess = refinementProcess; }
 
    int level() const;
 
    QList<QgsChunkNode *> descendants();
 
    //
    // changes of states in the state machine (see State enum)
    //
 
    void setQueuedForLoad( QgsChunkListEntry *entry );
 
    void cancelQueuedForLoad();
 
    void setLoading( QgsChunkLoader *chunkLoader );
 
    void cancelLoading();
 
    void setLoaded( Qt3DCore::QEntity *mEntity );
 
    void unloadChunk();
 
    void setQueuedForUpdate( QgsChunkListEntry *entry, QgsChunkQueueJobFactory *updateJobFactory );
 
    void cancelQueuedForUpdate();
 
    void setUpdating();
 
    void cancelUpdating();
 
    void setUpdated();
 
    void setExactBbox( const QgsAABB &box );
 
    void updateParentBoundingBoxesRecursively() const;
 
    void setHasData( bool hasData ) { mHasData = hasData; }
    bool hasData() const { return mHasData; }
 
  private:
    QgsAABB mBbox;      
    float mError;    
 
    QgsChunkNodeId mNodeId;  
 
    QgsChunkNode *mParent;        
    QVector<QgsChunkNode *> mChildren;   
    bool mChildrenPopulated = false;     
 
    State mState;  
 
    Qgis::TileRefinementProcess mRefinementProcess = Qgis::TileRefinementProcess::Replacement;  
 
    QgsChunkListEntry *mLoaderQueueEntry;       
    QgsChunkListEntry *mReplacementQueueEntry;  
 
    QgsChunkLoader *mLoader;         
    Qt3DCore::QEntity *mEntity;   
 
    QgsChunkQueueJobFactory *mUpdaterFactory;  
    QgsChunkQueueJob *mUpdater;                
 
    QTime mEntityCreatedTime;
    bool mHasData = true;   
};
 
 
#endif // CHUNKNODE_H