qgschunknode.h

Go to the documentation of this file.

/***************************************************************************
  qgschunknode.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_H
#define QGSCHUNKNODE_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 "qgis.h"
#include "qgsaabb.h"
#include "qgsbox3d.h"
 
#include <QString>
#include <QTime>
 
using namespace Qt::StringLiterals;
 
#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 u"%1/%2/%3"_s.arg( d ).arg( x ).arg( y ); // quadtree
      else
        return u"%1/%2/%3/%4"_s.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 QgsBox3D &box3D, float error, QgsChunkNode *parent = nullptr );
 
    ~QgsChunkNode();

    enum State
    {
      Skeleton,        
      QueuedForLoad,   
      Loading,         
      Loaded,          
      QueuedForUpdate, 
      Updating,        
    };

    QgsBox3D box3D() const { return mBox3D; }
    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 replaceEntity( Qt3DCore::QEntity *newEntity );

    void setExactBox3D( const QgsBox3D &box3D );

    void updateParentBoundingBoxesRecursively() const;

    void setHasData( bool hasData ) { mHasData = hasData; }
    bool hasData() const { return mHasData; }
 
  private:
    QgsBox3D mBox3D; 
    float mError;    
 
    QgsChunkNodeId mNodeId; 
 
    QgsChunkNode *mParent;             
    QVector<QgsChunkNode *> mChildren; 
    bool mChildrenPopulated = false;   
 
    State mState = Skeleton; 
 
    Qgis::TileRefinementProcess mRefinementProcess = Qgis::TileRefinementProcess::Replacement; 
 
    QgsChunkListEntry *mLoaderQueueEntry = nullptr;      
    QgsChunkListEntry *mReplacementQueueEntry = nullptr; 
 
    QgsChunkLoader *mLoader = nullptr;    
    Qt3DCore::QEntity *mEntity = nullptr; 
 
    QgsChunkQueueJobFactory *mUpdaterFactory = nullptr; 
    QgsChunkQueueJob *mUpdater = nullptr;               
 
    QTime mEntityCreatedTime;
    bool mHasData = true; 
};

 
#endif // CHUNKNODE_H