DtOsgEarthCache.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2020 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/


#pragma once

#include <vrvOsgEarth/vrvOsgEarth.h>
#include <osgEarth/Bounds>
#include <osgEarth/Progress>
#include <vrvUtil/DtUnicode.h>
#include <vrvUtil/DtVirtualBaseClass.h>

// Class Forward Declarations
namespace osgEarth
{
   class MapNode;
   class TileKey;
   namespace Util {
      class TileVisitor;
   }
   namespace Contrib {
      class CacheSeed;
   }
}

namespace osg
{
   class Camera;
}

namespace osgDB
{
   class DatabasePager;
}

namespace makVrv
{
   // Class Forward Declarations
   class DtDe;
   class DtOsgEarthCacheProgressCallback;
   class DtObserverObject;
   class DtOsgEarthCacheTileHandler;
   class DtChannel;

   class DT_DLL_VRVOSGEARTH DtOsgEarthCache
   {
   public:
      friend class DtOsgEarthCacheCreator;

      //let the WidgetProgressCallback emit updateProgress signal
      friend class DtWidgetProgressCallback;

      enum Method
      {
         API_CACHE,
         FLY_VIEWPOINT_CACHE
      };

      virtual ~DtOsgEarthCache();

      virtual void setMapNode(osgEarth::MapNode* mapNode);

      virtual void setLowestLod(int lowestLod);

      virtual int lowestLod() const;

      virtual void setHighestLod(int highestLod);

      virtual int highestLod() const;

      virtual void setCacheMethod(Method method);

      virtual Method cacheMethod() const;

      virtual void setBound(const osgEarth::Bounds& bound);

      virtual osgEarth::Bounds bound() const;

      virtual void setCacheImageLayers(bool val);

      virtual void setCacheElevationLayers(bool val);

      virtual void initializeChannel(DtChannel* channel);

      virtual void reset();

      virtual void startCache();

      virtual void apiCache();

      virtual void viewPointCache();

      virtual void cancelCache();

      virtual bool isCanceled();

   public:

      boost::signalslib::signal<void(int)>   signal_updateProgress;
      boost::signalslib::signal<void(std::string)>   signal_updateProgressText;
      boost::signalslib::signal<void()>   signal_cacheFinished;

   private:

      DtOsgEarthCache();
      DtOsgEarthCache(const DtOsgEarthCache &);
      DtOsgEarthCache &operator=(const DtOsgEarthCache &);

   protected:

      DtOsgEarthCache(DtDe& de);

      class DT_DLL_VRVOSGEARTH DtOsgEarthCacheProgressCallback : public osgEarth::ProgressCallback
      {
      public:

         DtOsgEarthCacheProgressCallback(DtOsgEarthCache* osgEarthCache);

         virtual ~DtOsgEarthCacheProgressCallback();

         bool reportProgress(
            double             current,
            double             total,
            unsigned           currentStage,
            unsigned           totalStages,
            const std::string& msg);

      protected:
         DtOsgEarthCache * myOsgEarthCache;
         int myCurrentProgress;
      };

   protected:
      DtDe & myDe;
      Method myCacheMethod;
      osgEarth::Bounds myBound;
      int myLowestLod;
      int  myHighestLod;
      osgEarth::MapNode* myMapNode;
      osg::ref_ptr<osgEarth::Util::TileVisitor> myTileVisitor;
      osgEarth::Contrib::CacheSeed* myCacheSeed;
      osg::ref_ptr<DtOsgEarthCacheProgressCallback> myProgressCallback;
      osg::ref_ptr<DtOsgEarthCacheTileHandler> myTileHandler;

      bool myCanceled;
      std::string myCurrentProcessingTile;
      bool myCacheImage;
      bool myCacheElevation;
   };

   class DT_DLL_VRVOSGEARTH DtOsgEarthCacheCreator
      : public DtVirtualBaseClass
   {
   public:
      static DtOsgEarthCacheCreator& instance(DtDe& de);
      static void registerInstance(DtDe& de, DtOsgEarthCacheCreator* creator);
      virtual DtOsgEarthCache* create(DtDe& de) const;
   };
}