DtIndirectFeatureGeomHandler.h

Go to the documentation of this file.

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


#pragma once

#include <osgdb_osgearth_model_feature_custom/CustomFeatureNode.h>

#include <vrvOsgEarth/vrvOsgEarth.h>

#include <vrvIndirectRendering/DtIndirectFadeParameters.h>

#include <vrvCore/DtVirtualBaseClassCreator.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <osgEarth/StateSetCache>
#include <osgEarth/Layer>

#include <osg/observer_ptr>

#include <boost/thread/mutex.hpp>
#include <boost/thread/condition_variable.hpp>

#include <tbb/atomic.h>
#include <tbb/task.h>

#include <unordered_map>
#include <unordered_set>

namespace osgEarth
{
   class Layer;
   class SubstituteModelFilterNode;
   class ExtrudeGeometryFilterNode;
}
namespace osg
{
   class Node;
   class Group;
}

namespace makVrv
{
   class DtDe;
   class DtCellToGeoTypicalIndirectGeoMap;
   class DtCellToGeoSpecificIndirectGeoMap;
   class DtIndirectModelsContainer;
   class DtModelSemanticsMapper;
   class DtIndirectFeatureGeomHandler;
   class DtCellIndirectGeo;

   class DT_DLL_VRVOSGEARTH DtIndirectFeatureGeomHandlerAsyncLoader : public tbb::task
   {
   public:
      DtIndirectFeatureGeomHandlerAsyncLoader(DtIndirectFeatureGeomHandler* handler,
         std::string  requestMarkerName);
      virtual tbb::task* execute();

   public:
   protected:
      DtIndirectFeatureGeomHandler * myHandler;
      std::string myRequestMarkerName;
   };

   class DtIndirectFeatureGeomHandler;

   typedef DtVirtualBaseClassCreator<DtIndirectFeatureGeomHandler, const osgEarth::Layer&, const DtIndirectFadeParameters&, const bool&, const bool&> DtIndirectFeatureGeomHandlerCreator;

   template <>
   inline const char* creatorTypeName<DtIndirectFeatureGeomHandler>(void) { return "DtIndirectFeatureGeomHandlerCreator"; }

   class DT_DLL_VRVOSGEARTH DtIndirectFeatureGeomHandler
   {
   public:
      virtual ~DtIndirectFeatureGeomHandler();

   protected:
      DtIndirectFeatureGeomHandler(DtDe& de, const osgEarth::Layer& layer, const DtIndirectFadeParameters& fadeParameters, bool dynamicTerrainInstallerActive, bool cullFaceEnabled);

      friend DtIndirectFeatureGeomHandlerCreator;

   private:
      DtIndirectFeatureGeomHandler(const DtIndirectFeatureGeomHandler &other) = delete;
      DtIndirectFeatureGeomHandler &operator=(const DtIndirectFeatureGeomHandler &other) = delete;
   
   public:
      virtual void onDataPremerge(osg::Node* data);

      virtual void onDataUnloaded(const osg::Node* data);

      virtual const osg::Node* preloadModelAndRunDynamicTerrainParser(const std::string& modelName);

      virtual void markTaskFinished();

      virtual void slot_postTick();

   protected:
      virtual void processSubstituteModelFilterNodes(osg::Node* data);

      virtual void processExtrudeGeometryFilterNodes(osg::Node* data);

      virtual void processExtrudeGeometryFilterNode(osgEarth::ExtrudeGeometryFilterNode* pFeatureNode, osg::Node* data);


      virtual void processSubstituteModelFilterNode(const osgEarth::SubstituteModelFilterNode* pFeatureNode, const osg::Node* data);
      
      virtual void processSubstituteModelFilterNodeAsGT(const osgEarth::SubstituteModelFilterNode* pFeatureNode, const osg::Group* keyNode);
      
      virtual void processSubstituteModelFilterNodeAsGS(const osgEarth::SubstituteModelFilterNode* pFeatureNode, const osg::Group* keyNode);

      virtual void processCustomFeatures(osg::Node* data);

      virtual void processCustomFeature(const osgEarth::CustomFeatureNode* pFeatureNode, const osg::Node* key);

      virtual void setLayerMask(const osgEarth::Layer* layer) const;

      virtual void turnOffIntersectionsIfSoSpecified(const osgEarth::Layer* layer) const;

   protected:
      
      DtDe& myDe;
      osg::observer_ptr<const osgEarth::Layer> myLayer;

      DtCellToGeoTypicalIndirectGeoMap* myCellToGTIndirectGeoMap;
      DtIndirectModelsContainer* myGTModelsContainer;

      DtCellToGeoSpecificIndirectGeoMap* myCellToGSIndirectGeoMap;

      DtCellToGeoSpecificIndirectGeoMap* myCellToProceduralGSIndirectGeoMap;

      DtModelSemanticsMapper& myModelSematicsMapper;

      boost::mutex myProcessedNodeMapMutex;
      boost::condition_variable myProcessedNodeMapCondition;
      typedef osg::ref_ptr<const osg::Node> NodeRefPtr;
      std::map<std::string, NodeRefPtr > myProcessedNodeMap;
      std::map<std::string, bool > myIsProcessingNodeMap;
      

      static tbb::atomic<int> theTotalNumActiveAsyncTasks;

      tbb::atomic<int> myActiveAsyncTasks;

      boost::condition_variable myWaitCondition;
      boost::mutex myWaitMutex;

      osg::ref_ptr< osgEarth::StateSetCache > myStateSetCache;

      DtIndirectFadeParameters myFadeParameters;

      const bool myDynamicTerrainInstallerActive;
      const bool myCullFaceEnabled;

      DtSignalConnectionManager myConnections;

      // Keep a set of models that could not be read and that we logged a warning for
      // so, that we log the warning only once.
      // This is because many feature markers could refer to the same model (that is not found)
      std::unordered_set<std::string> myWarningLoggedForNotFoundModel;
   };
}