terrainPagerCommand.h

Go to the documentation of this file.

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



#pragma once

#include <geometry/chord.h>
#include <geometry/sphere.h>
#include <osgTerrain/TerrainTile>

#include <vantageTerrainImplementation/vantageTerrainImplementationUtil.h>
#include <vantageTerrainImplementation/vantageTerrainImplementationDefines.h>

#include <vrfutil/objectCounter.h>

class DtTerrainPagerCommandFactory;
class DtTerrainSourcePager;

class DT_DLL_vantageTerrainImplementation DtTerrainPagerCommand
#ifdef DtObjectDebugger_Enable
   : public DtObjectDebugger<DtTerrainPagerCommand>
#endif
{
public:
   class DT_DLL_vantageTerrainImplementation CommandCounter
   {
   public:
      virtual ~CommandCounter() { }

   private:
      friend class DtTerrainPagerCommand;

      virtual void incrementCommandCount() = 0;
      virtual void decrementCommandCount() = 0;
   };

   DtTerrainPagerCommand(const DtPagingMetaDataPtr& metaData)
   : myMetaData(metaData)
   , myComplete(false)
   , myProcessing(false)
   , myCount(0)
   , myMutex()
   {
   };

   virtual ~DtTerrainPagerCommand()
   {
      if (myCount)
         myCount->decrementCommandCount();
   };

   virtual void setCount(CommandCounter& count)
   {
      if (myCount)
         myCount->decrementCommandCount();

      myCount = &count;

      if (myCount)
         myCount->incrementCommandCount();
   }

   virtual void execute(DtTerrainSourcePager* pager) = 0;

   virtual const bool complete() 
   {
      tbb::spin_mutex::scoped_lock lock(myMutex);
      return myComplete; 
   }

   virtual const bool processing()
   {
      tbb::spin_mutex::scoped_lock lock(myMutex);
      return myProcessing;
   }

   virtual void startProcessing()
   {
      tbb::spin_mutex::scoped_lock lock(myMutex);
      myProcessing = true;
   }

   virtual void stopProcessing()
   {
      tbb::spin_mutex::scoped_lock lock(myMutex);
      myProcessing = false;
   }

   virtual const DtPagingMetaDataPtr metaData() 
   {
      tbb::spin_mutex::scoped_lock lock(myMutex);
      return myMetaData; 
   }

   virtual const int type() const = 0;

   static DtTerrainPagerCommandFactory* factory();
   
protected:
   mutable tbb::spin_mutex myMutex;
   DtPagingMetaDataPtr myMetaData;
   bool myComplete;
   bool myProcessing;
   CommandCounter* myCount;

   static DtTerrainPagerCommandFactory theFactory;
};

DT_DEFINE_OBJECT_DEBUGGER_NAME(DtTerrainPagerCommand);

template <typename T_Pager>
class DtTerrainPagerSpecificCommand : public DtTerrainPagerCommand
{
public:
   DtTerrainPagerSpecificCommand(DtPagingMetaDataPtr metaData)
      : DtTerrainPagerCommand(metaData)
   {

   }

   virtual ~DtTerrainPagerSpecificCommand()
   {
   };


   virtual void execute(DtTerrainSourcePager* pager)
   {
      T_Pager* specificPager = static_cast<T_Pager*>(pager);
      execute(specificPager);
   }

   virtual void execute(T_Pager* pager) = 0;
};