DtOsgEarthFeatureDataBroker.h

Go to the documentation of this file.

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


#pragma once
#include <vrvOsg/vrvOsg.h>
#include <osg/observer_ptr>
#include <osg/ref_ptr>

#include <osgEarth/Map>
#include <osgEarth/SceneGraphCallback>
#include <boost/unordered_map.hpp>

#include <set>
#include <string>

// Forward declarations
namespace osg {
   class Node;
}
namespace osgEarth {
   class MapNode;
   class ModelLayer;
}

namespace makVrv
{
   class FeaturePageObserver;

   class DT_DLL_VRVOSG DtOsgEarthFeatureDataBroker : public osg::Referenced
   {
   public:
      // Callback to invoke when new data merges into the scene graph.
      class DT_DLL_VRVOSG Callback : public osg::Referenced
      {
      public:
         virtual void onLayerLoaded(const osgEarth::MapNode*    mapNode,
                                    const osgEarth::ModelLayer* layer) =0;
         
         virtual void onDataPreMerge(const osgEarth::Map*        map,
            const osgEarth::ModelLayer* layer,
            osg::Node*            newData) = 0;

         virtual void onDataLoaded(const osgEarth::Map*        map,
                                   const osgEarth::ModelLayer* layer,
                                   const osg::Node*            newData) = 0;

         // Implementation of this method is optional; currently both speedtree
         // and buoys/beacons have their own mechanism that they use (but should
         // switch over to this eventually); and some users (like the texture installer)
         // don't need to know when stuff pages out.
         virtual void onDataUnloaded(const osgEarth::Map* map, const osgEarth::ModelLayer* layer, const osg::Node* oldData)
         {
         }
      };

   public:
      // Constructs a broker for the specified map node.
      DtOsgEarthFeatureDataBroker(osgEarth::MapNode* mapNode, DtDe& de);

      // Install a callback.
      //sending an empty string for the registrant makes this callback applied to all features regardless of name.
      void addCallback(const std::string& registrant, Callback* cb);

      // Whether to run state sharing optimization after invoking
      // all the callbacks. Default = true.
      void setOptimizeStateSharing(bool value);
      bool getOptimizeStateSharing() const;

   public: // internal functions

      // Adds a model layer to the broker. You normally do not need to
      // call this directly; the object will discover model layers in the
      // Map model automatically.
      void addModelLayer(osgEarth::ModelLayer* layer);

      // Internal function that's called after a new map layer is
      // loaded in the MapNode.
      void notifyNewLayer(osgEarth::ModelLayer* layer);

      // Internal function that's called before new data for the model
      // layer merges into the scene graph. This is called internally;
      // there is no need to call it yourself.
      // Potentially called in a background thread so be careful about threading issues
      void notifyPreMergeData(osgEarth::ModelLayer* layer, osg::Node* node);

      // Internal function that's called after new data for the model
      // layer merges into the scene graph. This is called internally;
      // there is no need to call it yourself.
      void notifyNewData(osgEarth::ModelLayer* layer, osg::Node* data);

      // When new data arrives, an osg::observer is attached to it; this method
      // is called when the observer detects the deletion of the data
      void notifyDataDeleted(osgEarth::ModelLayer* layer, osg::Node* data);

   protected:
      virtual ~DtOsgEarthFeatureDataBroker();

      bool readFeatureNameRegistrationFile( const std::string& path, 
         const std::string& filename );

   protected:
      std::string getFeatureNameFromModelLayer( const osgEarth::ModelLayer& layer );

   protected:
      static const char* theFeatureDataBrokerRegistrantToFeatureList;

   protected:

      typedef osg::ref_ptr<osgEarth::SceneGraphCallback> SceneGraphCallbackRefPtr;
      osg::observer_ptr<osgEarth::MapNode> myMapNode;
      osg::ref_ptr<osgEarth::MapCallback> myMapCallback;
      std::set<SceneGraphCallbackRefPtr> myOperations;
      DtDe& myDe;
      bool myShareState;
      OpenThreads::Mutex myMapMutex;

      typedef osg::ref_ptr<Callback> CallbackRefPtr;
      typedef boost::unordered_multimap<std::string, CallbackRefPtr> 
         FeatureDataCallbackMap;
      typedef std::pair<FeatureDataCallbackMap::iterator,
         FeatureDataCallbackMap::iterator> RangeIterFeatureDataCallbacks;
      typedef std::pair<FeatureDataCallbackMap::const_iterator,
         FeatureDataCallbackMap::const_iterator> 
         ConstRangeIterFeatureDataCallbacks;

      FeatureDataCallbackMap myFeatureDataCallbacks;

      typedef std::set<CallbackRefPtr> CallbackRefSet;
      //Callbacks which run on all features regardless of their name. 
      // Add to this list by calling addCallback with "" as the class name.
      CallbackRefSet myAllFeatureCallbacks;

      typedef boost::unordered_map<std::string, std::vector<std::string> > 
         RegistrantToFeaturesMap;

      typedef boost::unordered_map<std::string, 
         std::vector<std::string> >::iterator RegistrantToFeaturesMapIter;

      RegistrantToFeaturesMap myRegistrantToFeaturesMap;

      //added to speed up lookup since building the config structure is slow currently
      boost::unordered_map<const osgEarth::ModelLayer*, std::string> myFeatureNameLookup;

      typedef boost::unordered_map<osg::Node*, FeaturePageObserver*> MapPagesToObservers;
      MapPagesToObservers myMapPagesToObservers;
   };
}