DtOsgEarthFeatureDataBroker.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvUtil/DtVirtualBaseClass.h>

#include <vrvIndirectRendering/DtGpuCullingAndLodDefines.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 Layer;
}

namespace makVrv
{
   class FeaturePageObserver;
   class DtOsgShaderManager;

   // namespace to delineate these orders from makVrv
   namespace DtOsgEarthFeatureDataBrokerCallbackOrders
   {
      const static float DefaultOrder = 1.0f;
      const static float OsgEarthEffectTextureInstallerCallbackOrder = 1.5f;
      const static float OsgEarthStreamedFeatureCallbackOrder = 2.0f;
      const static float OsgEarthDynamicTerrainInstallerOrder = 5.0f;
      const static float OsgEarthLightPointInstallerOrder = 7.0f; //needs to be after the dynamic terrain installer
   }
   
   
   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,
                                    osgEarth::Layer* layer) =0;
         
         virtual void onDataPreMerge(const osgEarth::Map*        map,
            const osgEarth::Layer* layer,
            osg::Node*            newData) = 0;

         virtual void onDataLoaded(const osgEarth::Map*        map,
                                   const osgEarth::Layer* 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::Layer* layer, const osg::Node* oldData)
         {
         }

         virtual float callbackOrder() 
         { 
            return DtOsgEarthFeatureDataBrokerCallbackOrders::DefaultOrder;
         }

         DtIndirectFadeParameters parseFadeParametersForLayer(const osgEarth::MapNode* mapNode, osgEarth::Layer* layer);

         virtual const std::string& instanceClassName() const = 0;

      protected:
         static bool isModelLayer(const osgEarth::Layer* layer);
      };

      class DT_DLL_VRVOSG CallbackSortFunction
      {
      public:
         bool operator()(Callback* a, Callback* b) const
         {
            if (a->callbackOrder() != b->callbackOrder())
               return a->callbackOrder() < b->callbackOrder();
            else
               return a < b;
         }
      };

      typedef osg::ref_ptr<Callback> CallbackRefPtr;
      typedef std::set<CallbackRefPtr, CallbackSortFunction> SortedCallbackRefSet;

   protected:
      DtOsgEarthFeatureDataBroker(osgEarth::MapNode* mapNode, DtDe& de);
   
      friend class DtOsgEarthFeatureDataBrokerCreator;

      virtual ~DtOsgEarthFeatureDataBroker();

   private:
      DtOsgEarthFeatureDataBroker(const DtOsgEarthFeatureDataBroker &other);
      DtOsgEarthFeatureDataBroker &operator=(const DtOsgEarthFeatureDataBroker &other);

   public:
      // 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 layer to the broker. You normally do not need to
      // call this directly; the object will discover layers in the
      // Map model automatically.
      void addLayer(osgEarth::Layer* layer);

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

      bool layerHasCallback(const osgEarth::Layer* layer, const std::string& className);

      // Internal function that's called before new data for the
      // 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::Layer* layer, osg::Node* node);

      // Internal function that's called after new data for the 
      // layer merges into the scene graph. This is called internally;
      // there is no need to call it yourself.
      void notifyNewData(osgEarth::Layer* 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::Layer* layer, osg::Node* data);

      DtDe& getDe() { return myDe; }

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

   protected:
      std::string getFeatureNameFromLayer( const osgEarth::Layer& 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 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 boost::unordered_map<std::string, SortedCallbackRefSet>
         LayerToCallbackMap;

      LayerToCallbackMap myLayerToCallbackMap;

      //Callbacks which run on all features regardless of their name. 
      // Add to this list by calling addCallback with "" as the class name.
      SortedCallbackRefSet 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::Layer*, std::string> myFeatureNameLookup;

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

      DtOsgShaderManager& myShaderManager;
   };

   class DT_DLL_VRVOSG DtOsgEarthFeatureDataBrokerCreator : public DtVirtualBaseClass
   {

   public:
      DtOsgEarthFeatureDataBrokerCreator();

      virtual ~DtOsgEarthFeatureDataBrokerCreator();

   private:
      DtOsgEarthFeatureDataBrokerCreator(const DtOsgEarthFeatureDataBrokerCreator &other);
      DtOsgEarthFeatureDataBrokerCreator &operator=(const DtOsgEarthFeatureDataBrokerCreator &other);

   public:
      static DtOsgEarthFeatureDataBrokerCreator& instance(DtDe& de);

      static void registerInstance(DtDe& de,
         DtOsgEarthFeatureDataBrokerCreator* instance);

      virtual DtOsgEarthFeatureDataBroker* create(osgEarth::MapNode* mapNode, DtDe& de);

   };
}