DtStreamedSpeedTreeThread.h

Go to the documentation of this file.

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


#pragma once

#include <vrvSt/vrvSt.h>

#include <vrvCore/DtTreeRecord.h>

#include <vrvUtil/DtVirtualBaseClass.h>

#include <osgdb_osgearth_model_feature_custom/CustomFeatureNode.h>

#include <osg/ref_ptr>
#include <osg/OperationThread>

#include <OpenThreads/Thread>
#include <OpenThreads/Block>

#include <boost/thread/mutex.hpp>
#include <boost/unordered_set.hpp>
#include <tbb/atomic.h>
#include <tbb/task.h>
#include <deque>

namespace osg
{
   class Node;
   class RenderInfo;
   class EllipsoidModel;
}

namespace osgUtil
{
   class SceneView;
}

namespace makVrv 
{
   class DtDe;
   class DtStreamedSpeedTreeForest;
   class DtSpeedTreeMergeJob;
   class DtStreamedSpeedTreeThread;
   
   class DT_DLL_VRVST DtSpeedTreeMergeJob : public osg::Operation
   {
   public:
      DtSpeedTreeMergeJob(DtStreamedSpeedTreeThread * stThread);
      virtual void operator () (osg::Object* sv);
      
      virtual void release();

      DtStreamedSpeedTreeThread * myThread;
   };

   class DT_DLL_VRVST DtSpeedTreeMergeTask : public tbb::task
   {
   public:
      DtSpeedTreeMergeTask(DtStreamedSpeedTreeThread * stThread, osgUtil::SceneView* sceneView);
      virtual tbb::task* execute();

      DtStreamedSpeedTreeThread * myThread;
      osgUtil::SceneView* mySceneView;
   };

   class DT_DLL_VRVST DtStreamedSpeedTreeThread : public OpenThreads::Thread, public DtVirtualBaseClass
   {
   public:
      static DtStreamedSpeedTreeThread& instance(DtDe& de);

      virtual ~DtStreamedSpeedTreeThread();

      enum RequestStatus { UNUSED, WORKING, DONE };

       
      struct TreeRequestOutput
      {
         std::vector<DtVectorTreeRecords> myRecordsArray;

         DtStreamedSpeedTreeForest* myForest;

         const osg::Node* myDataNode;


         volatile RequestStatus myStatus;
      };

      class TreeRequestMsg
      {
      public:
         TreeRequestMsg()
             : myOutput(NULL)
             , myForest(NULL)
             , myUseScaleRandomization(false)
             , myUseOrientationRandomization(false)
             , myTreeMinScale(1.0)
             , myTreeMaxScale(1.0)
             , myDataNode(NULL)
         { ; }
         ~TreeRequestMsg() { ; }

         osg::ref_ptr< const osgEarth::CustomFeatureNode> myFeatureNode;

         TreeRequestOutput* myOutput;

         DtStreamedSpeedTreeForest* myForest;

         bool myUseScaleRandomization;
         bool myUseOrientationRandomization;
         float myTreeMinScale;
         float myTreeMaxScale;

         const osg::Node* myDataNode;

      private: 
         TreeRequestMsg(const TreeRequestMsg &other);
         TreeRequestMsg &operator=(const TreeRequestMsg &other);
      };

      typedef std::list<TreeRequestOutput> RequestOutputList;

      typedef boost::unordered_set<const osg::Node*> NodeSet;

      typedef boost::unordered_set<DtStreamedSpeedTreeForest*> ForestSet;

      typedef boost::unordered_set<std::string> StringSet;

      RequestOutputList& requestOutput();

      NodeSet& unloaded();

      void setForestDeleted(DtStreamedSpeedTreeForest* forest);

      void setNodeUnloaded(const osg::Node* node);

      void enqueue(
         const osgEarth::CustomFeatureNode *featureNode,
         TreeRequestOutput* out,
         DtStreamedSpeedTreeForest* forest,
         const osg::Node* dataNode,
         bool useScaleRandomization, 
         bool useOrientationRandomization,
         float treeMinScale,
         float treeMaxScale);

      virtual void run();

      void handleRequest(const TreeRequestMsg& msg);

      bool isForestDeleted(DtStreamedSpeedTreeForest* forest);

      bool isNodeUnloaded(const osg::Node* node);

      static std::size_t hash_value(const std::string& modelDefName, 
         const osgEarth::CustomFeatureNode::OsgEarthMarkerRequest& val);

      void mergeTreeRequests(osg::RenderInfo& renderInfo);

      void block();

      void release();

      virtual void updateBlock();

      virtual void stopMergingWork() { myStopWork = true; }

      virtual bool workToDo() { return myWorkToDo; }
      virtual bool runningMerge() { return myRunningMerge; }
   protected:

      DtStreamedSpeedTreeThread(DtDe& de);

      virtual double rotationAngleFromGeocentricQuaternion(const osg::Quat& rotation,
         const osg::Vec3d& location);

      private:
         DtStreamedSpeedTreeThread();

   protected:

      DtDe& myDe;

      std::deque<TreeRequestMsg*> myMessageQueue;

      // Don't keep spinning if we don't have data
      OpenThreads::Block myBlock;

      boost::mutex myMessageQueueMutex;

      StringSet myValidModelDefinitions;

      ForestSet myDeletedForests;

      RequestOutputList myTreeRequestOutput;

      NodeSet myUnloadedNodes;

      bool myTimeToStop;

      osg::EllipsoidModel* myEllipsoidModel;

      tbb::atomic< bool> myStopWork;
      tbb::atomic< bool> myWorkToDo;
      tbb::atomic < bool> myRunningMerge;

   };
}