DtOsgEarthPaperMapManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsgEarth/vrvOsgEarth.h>
#include <osgEarth/MapCallback>

#include <vrvCore/DtPaperMapManagerSignaler.h>
#include <vrvCore/DtTickable.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <osgEarth/VisibleLayer>

#include <map>
#include <set>

namespace makVrv
{
   class DtTerrainPatchObject;
   class DtObserverObject;
   class DtObserver;
   class DtInputDriver;

   class DT_DLL_VRVOSGEARTH DtOsgEarthPaperMapManager : public DtTickable, public DtVirtualBaseClass
   {
   public:

      enum ShowIn
      {
         SHOW_IN_2D_AND_3D,
         SHOW_IN_2D,
         SHOW_IN_3D
      };

      DtOsgEarthPaperMapManager() = delete;

      virtual ~DtOsgEarthPaperMapManager();

      DtOsgEarthPaperMapManager(DtOsgEarthPaperMapManager& in) = delete;

      DtOsgEarthPaperMapManager& operator=(const DtOsgEarthPaperMapManager&) = delete;

      virtual void addToGroups(std::string groupStr, osgEarth::VisibleLayer* layer, bool isect);

      virtual void addToGroup(std::string groupName, osgEarth::VisibleLayer* layer, bool isect);

      virtual void activateGroup(std::string groupName);

      std::string activeGroup();

      virtual void reset();

      virtual void resetGroupMasks();

      virtual void enableAllGroupMasks();

      virtual void defaultGroupMasksVisible(ShowIn show);

      virtual bool hasGroup(const std::string& groupName);

      virtual void updateAnyObserver3D();

      virtual void addLayer(osgEarth::Layer* layer);

      virtual void removeLayer(osgEarth::Layer* layer);

      virtual void printState();

      virtual std::vector<std::string> groupNames();

      virtual void update(DtTime tNow) override;

      virtual void closeLayer(osgEarth::VisibleLayer* layer);

      virtual void openLayer(osgEarth::VisibleLayer* layer);

      virtual DtTime lastUpdateTime() const;

      virtual std::vector<std::string> getGroupsForLayer(osgEarth::VisibleLayer* layer);

      virtual bool layerInActiveGroup(osgEarth::VisibleLayer* layer);

      virtual void removeGroup(std::string groupName);

   protected:
      friend class DtOsgEarthPaperMapManagerCreator;

      DtOsgEarthPaperMapManager(DtDe& de);

      virtual void slot_paperMapEnabledChanged(bool setting);

      virtual void slot_paperMapLayerTimeoutChanged(double timeout);

      virtual void slot_observerAdded(const std::string& observerName);

      virtual void slot_observerRemoved(const std::string& observerName);

      virtual void slot_onCurrentObserverChanged(DtInputDriver* inputDriver, DtObserver* observer);

      virtual void slot_observerGroupChanged(DtObserver* observer, std::string obsGroup);

      virtual void slot_projectionChanged(DtObserverObject* observer, bool is2D);

      virtual void slot_osgEarthMapNodeFound(DtTerrainPatchObject& tpo);

      virtual void slot_terrainPatchAboutToBeDeleted(DtTerrainPatchObject& patch);

      virtual void slot_paperMapIntersectionOverrideChanged(bool setting);

   public:

      static DtOsgEarthPaperMapManager& instance(DtDe& de);

      static const std::string& theClassName();

   protected:

      DtDe& myDe;

      DtSignalConnectionManager myConnections;

      typedef std::map<DtObserverObject*, bool> ObserverObj2DMap;
      typedef std::set<osgEarth::VisibleLayer*> PaperMapLayerSet;
      typedef std::map<std::string, PaperMapLayerSet > GroupLayerMap;
      typedef std::map<osgEarth::VisibleLayer*, bool > LayerBoolMap;
      typedef std::map<osgEarth::VisibleLayer*, DtTime> LayerTimeMap;

      GroupLayerMap myGroupMap;
      LayerBoolMap myLayerIsInDefault;
      LayerBoolMap myGroupIsect;
      std::string myActiveGroupName;

      // We need to keep track to see if any observers are in 2D (otherwise they are 3D)
      // Well actually DtObserverObjects because DtObservers are not on the slave
      ObserverObj2DMap myObserverObj2DMap;
      bool myAnyObserverIn3D;

      // Keep track of when layers are closed or reopened
      LayerTimeMap myLayerTime;
      double myLayerTimeOut;

      bool myPaperMapFeatureEnabled;
      bool myIntersectionOverride;

      DtObserver* myCurrentObserver;
   };

   class DT_DLL_VRVOSGEARTH DtOsgEarthPaperMapManagerCreator : public DtVirtualBaseClass
   {
   public:
      DtOsgEarthPaperMapManagerCreator();

      virtual ~DtOsgEarthPaperMapManagerCreator();

      DtOsgEarthPaperMapManagerCreator(DtOsgEarthPaperMapManagerCreator& in) = delete;

      DtOsgEarthPaperMapManagerCreator& operator=(const DtOsgEarthPaperMapManagerCreator& in) = delete;

      virtual DtOsgEarthPaperMapManager* create(DtDe& de);
   };
}