DtBackgroundLoader.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>

#include <vrvUtil/DtVirtualBaseClass.h>

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

#include <boost/thread.hpp>

#include <unordered_map>

// FIXME:
// This should not be in vrvCore!!
namespace osgUtil
{
   class StateToCompile;
}

namespace makVrv
{
   class DtDe;
   class DtModel;
   class DtBackgroundLoader;
   struct DtLoaderHandle;

   class DT_DLL_VRVCORE DtBackgroundLoader : public DtVirtualBaseClass
   {
   public:
      static DtBackgroundLoader& instance(DtDe& de);

      virtual ~DtBackgroundLoader();
   protected:
      DtBackgroundLoader(DtDe& de);
   private:
      DtBackgroundLoader() = delete;
      DtBackgroundLoader(const DtBackgroundLoader&) = delete;
      DtBackgroundLoader& operator=(const DtBackgroundLoader&) = delete;
   public:

      virtual void updateQueue(int max_thread_count, int active_threads);

      virtual DtLoaderHandle* queueForLoad(DtModel* object);

      virtual void setForegroundTimeBudget(double budget);

      virtual void incrementForegroundTime(double time_elapse);

      virtual bool isForegroundTimeBudgetExpired() const;

      virtual double timeSpentThisFrame() const;

      virtual void loadIfPossibleOrAddToQueue(DtModel* object);

      virtual bool hasActiveAsyncTasks() const;

      virtual int numModelDefinitionsToIco() const;
      virtual std::string nextModelDefinitionToIco();

      virtual int numOfActiveTasks() const;

      virtual void addToAdditionalIcoList(osgUtil::StateToCompile* compile);

      virtual std::list<osgUtil::StateToCompile*>& additionalToIcoList();

      virtual bool multithreadedLoadingActive() const;
      virtual void setMultithreadedLoadingActive(bool val);
   protected:
      virtual void timedForegroundLoad(DtModel* object);

      virtual void ts_setModelDefinitionLoaded(const std::string& modelDefinition);
      virtual bool ts_isModelDefinitionLoaded(const std::string& modelDefinition) const;

   protected:
      DtDe& myDe;

      friend class DtBackgroundLoadAsyncTask;

      boost::mutex myProducerQueueMutex;
      std::list< DtLoaderHandle* > myProducerQueue;
      std::list< DtLoaderHandle* > myForegroundQueue;
      std::list< std::string  > myModelDefsToIcoQueue;

      std::list<DtLoaderHandle* > myObjectsFinishedWithTBBTask;
      std::list<osgUtil::StateToCompile* >  myAdditionalToIcoList;

      boost::mutex myTaskFinishedMutex;
      std::list<DtLoaderHandle* > myObjectsToForegroundLoad;

      std::map<std::string, bool> myActivelyLoadingModelDefs;
      tbb::atomic<int> myNumberOfActiveTasks;

      double myTimeSpentThisFrame;
      mutable boost::mutex myMutableLoadedDefMapMutex;
      std::unordered_map<std::string, bool> myLoadedDefMap;

      double myForegroundTimeBudget;
      bool myMultithreadedLoadingActive;
   };
};