DtMainThreadJobsManager.h

Go to the documentation of this file.

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


#pragma once

#include <osg/OperationThread>
#include <osgUtil/IncrementalCompileOperation>
#include <osgUtil/SceneView>

#include <tbb/atomic.h>

#include <vrvOsg/vrvOsg.h>
#include <vrvOsg/DtOsgRenderer.h>
#include <vrvOsg/DtOsgThreadingUtils.h>
#include <vrvUtil/DtVirtualBaseClass.h>

namespace makVrv
{

  



   class DT_DLL_VRVOSG DtMainThreadJobsManager : public osg::Operation
   {
   public:
      DtMainThreadJobsManager(DtDe& de);

      virtual ~DtMainThreadJobsManager() 
      { 
          // Raising exception in destructor is illegal
          try {
              // The viewer is getting rid of us, so tell the renderer
              // so that is doesn't try to delete us again
              DtOsgRenderer& renderer = dynamic_cast<DtOsgRenderer&>(myDe.renderer());
              renderer.clearMainThreadJobsManager();
          }
          catch (...)
          {
              assert(false);
          }
      }

      virtual void operator () (osg::Object* obj);

      virtual void startUp();

      virtual void release();
      
      void setIco(osgUtil::IncrementalCompileOperation* ico);

      virtual void addPersistantJob(osg::Operation* job);

      virtual void removePersistantJob(osg::Operation* job);

      virtual void addTransientJob(osg::Operation* job);

      virtual void addRequiredTransientJob(osg::Operation* job);

      virtual int numberOfTransientJobs();

      virtual void finishFrameTime(double budget, osg::Object* obj);

      virtual double lastFrameTime() { return myLastFrameTime; }

   protected:

      virtual void runTransientJobs(osgUtil::SceneView* sceneView);

      std::vector<osg::ref_ptr<osg::Operation> > myPersistantJobs;
      
      std::vector<osg::ref_ptr<osg::Operation> > myRequiredTransientJobs;
      // transient jobs
      tbb::atomic<int> myNumberOfTransientJobs;
      std::vector<osg::ref_ptr<osg::Operation> > myTransientJobs;
      std::vector<osg::ref_ptr<osg::Operation> > myNextFrameJobs;

      osgUtil::IncrementalCompileOperation* myIco;
      OpenThreads::Mutex myMutex;
      OpenThreads::Condition myRunThreadWaitCond;
      tbb::atomic<bool> myKeepGoing;
      osg::ref_ptr<osg::Operation> myCurrentJob;
      
      double myLastFrameTime;

   private:
      DtMainThreadJobsManager(const DtMainThreadJobsManager& rhs);
      DtMainThreadJobsManager& operator=(const DtMainThreadJobsManager& rhs);

      DtDe& myDe;

   };



   class DT_DLL_VRVOSG DtMainThreadJobsManagerCreator : public DtVirtualBaseClass
   {
   public:
      DtMainThreadJobsManagerCreator(DtDe& de);

      virtual ~DtMainThreadJobsManagerCreator();
   private:
      DtMainThreadJobsManagerCreator(const DtMainThreadJobsManagerCreator& other);
      DtMainThreadJobsManagerCreator& operator=(const DtMainThreadJobsManagerCreator& other);
   public:
      virtual DtMainThreadJobsManager* create() const;

      static DtMainThreadJobsManagerCreator& instance(DtDe& de);

      static const std::string& theClassName();

   protected:
      DtDe& myDe;
   };
};