vantageTerrainEngine.h

Go to the documentation of this file.

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



#pragma once

#include <vantageTerrainImplementation/simDatabasePager.h>
#include <vantageTerrainImplementation/collisionWorld.h>
#include <vantageTerrainImplementation/terrainSourcePager.h>
#include <vantageTerrainImplementation/osgEarthTerrainSourcePager.h>
#include <vantageTerrainImplementation/terrainConfigurationOptions.h>
#include <terrainInterface/terrainImplementation.h>

//vrlink includes
#include <vlutil/vlPrint.h>
#include <vlutil/vlFilename.h>

//vrvantage includes
#include <makArchives/DtSceneRecord.h>

//osg includes
#include <osgDB/Registry>
#include <osgTerrain/TerrainTile>

//threadingBuildingBlocks includes
#include <tbb/concurrent_queue.h>
#include <tbb/tbb_thread.h>
#include <tbb/mutex.h>

#include <boost/scoped_ptr.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <features/feature.h>
#include <features/pathFeature.h>
#include <features/obstacleFeature.h>

class DtActivePageTracker;
class DtCollsionWorld;
class btIDebugDraw;
class DtCollisionWorld;
class DtString;
class DtSharedMemoryBulletDebugDrawer;
class DtTerrainEngineCommand;
class DtPageInVisitor;
class DtReadFileCallback;
class DtPageOutAllTerrainCommand;
class DtTerrainAltitudeTable;

namespace makVrv
{
   class DtDe;
   class DtCoordinateSystem;
}

typedef std::list<DtTerrainSourcePager*> DtTerrainSourcePagerList;


class DtVantageTerrainEngine
{
public:
   typedef std::map<std::string,std::string> TerrainSettings;

private:

   DtVantageTerrainEngine(const DtVantageTerrainEngine&);
   DtVantageTerrainEngine& operator=(const DtVantageTerrainEngine&);

public:
   DtVantageTerrainEngine(DtCollisionWorld* collisionWorld,
      DtActivePageTracker* pageTracker);
   virtual ~DtVantageTerrainEngine();

   virtual void tick();


   virtual bool loadTerrain(const DtString& filename,
      MAKVRinTerra::DtFeatureLoader&,
      const TerrainSettings& settings = TerrainSettings());

   virtual bool loadOsgEarthFile(const DtString& filename, MAKVRinTerra::DtFeatureLoader&);

   struct ProcessedMtf
   {
      typedef std::list<std::string> FileList;

      makArchives::DtTerrainRecord terrainRecord;

      FileList osgEarthFiles;
   };

   virtual ProcessedMtf processMtfFile(const DtString& filename);

   virtual bool processMapNode(osgEarth::MapNode* mapNode);

   virtual void startTerrainEngineThread();
   void stopTerrainEngineThread();


   virtual void setDatabasePager(osgDB::DatabasePager* databasePager) { theDatabasePager = databasePager; };

   virtual osg::ref_ptr<osgDB::DatabasePager> databasePager() { return theDatabasePager; };

   static DtVantageTerrainEngine* terrainEngine() 
   { return DtVantageTerrainEngine::theVantageTerrainEngine; };

   const makVrv::DtCoordinateSystem& coordSystem();

   virtual void setDebugDrawer(DtSharedMemoryBulletDebugDrawer* drawer);

   virtual DtSharedMemoryBulletDebugDrawer* debugDrawer() { return myDebugDrawer; };

   virtual DtActivePageTracker* pageTracker() { return myPageTracker; };

   virtual makVrv::DtDe* de();

   virtual DtCollisionWorld* collisionWorld();

   virtual void setLastIntersectId(unsigned int intersectId);

   virtual void setLoadImages(const bool& shouldLoadImages);

   //virtual osg::ref_ptr<osg::Node> terrainRoot(int childIndex);

   virtual DtDrawMode drawMode() const;
   virtual void setDrawMode(const DtDrawMode& drawMode);

   virtual const unsigned int numTriangles() const;
   virtual void setNumTriangles(const unsigned int& numTriangles);

   virtual const unsigned int triangleThreshold() const;
   virtual void setTriangleThreshold(const unsigned int& threshold);

   virtual void setConfigurationOptions(DtTerrainConfigurationOptions options);
   virtual const DtTerrainConfigurationOptions configurationOptions() const;

public:

   virtual void updatePageTracker();

   virtual void updateDrawer();

   bool threadShouldExit() const;

   virtual void updateCollisionObjectsDrawState();

   virtual void decrementPendingPageOutOperations();

   virtual void pageOutTerrainNextTick();

   virtual void expireCommandsBeforeTime(const double& currentTime);

   virtual const makArchives::DtTerrainRecord& loadedTerrainRecord();

   DtTerrainAltitudeTable* altitudeTable() { return myTerrainAltitudeTable.get(); }

protected:
   virtual makVrv::DtDe* createAndInitializeDe();
   virtual void reRegisterAgentCreators(makVrv::DtDe* de);

   static void threadMain(DtVantageTerrainEngine* terrainEngine);

   virtual std::list<std::string> vrvPluginsToLoad(const std::string& pluginDir);


protected:
   static makVrv::DtDe* theDe;
   static osg::ref_ptr<osgDB::DatabasePager> theDatabasePager;

   DtCollisionWorld* myCollisionWorld;
   DtActivePageTracker* myPageTracker;
   DtSharedMemoryBulletDebugDrawer* myDebugDrawer;
   tbb::concurrent_queue<DtTerrainEngineCommand*> myCommandQueue;
   tbb::tbb_thread* myTerrainEngineThread;
   mutable tbb::mutex myShutdownMutex;
   bool myThreadShutdown;

   mutable tbb::spin_rw_mutex myMutex;

   static DtReadFileCallback* theReadFileCallback;

   DtTerrainSourcePagerList myTerrainSourcePagers;

   static DtVantageTerrainEngine* theVantageTerrainEngine;

   DtDrawMode myDrawMode;
   bool myRedraw;

   unsigned int myLastIntersectId;
   unsigned int myPageOutTriangleThreshold;
   unsigned int myNumTriangles;
   unsigned int myPendingPageOutOperations;

   DtPageOutAllTerrainCommand* myPageOutTerrainCommand;
   bool myPageOutTerrainNextTick;

   DtTerrainConfigurationOptions myConfigurationOptions;
   makArchives::DtTerrainRecord myLoadedTerrain;

   TerrainSettings mySettings;

   boost::scoped_ptr<DtTerrainAltitudeTable> myTerrainAltitudeTable;

   static bool theWorkLeft;
};

class DtNodeUserData : public osg::Referenced
{
public:

   inline DtNodeUserData() 
      : osg::Referenced()
      , myCollisionObject(0)
      , myPendingRequestId(-1)
   {
   };


   virtual btCollisionObject* collisionObject() const { return myCollisionObject; };
   virtual void setCollisionObject(btCollisionObject* collisionObject) { myCollisionObject= collisionObject; };


   virtual const int pendingRequestId() const { return myPendingRequestId; };
   virtual void setPendingRequestId(int id) { myPendingRequestId = id; };

protected:

   virtual ~DtNodeUserData() {};

   btCollisionObject* myCollisionObject;

   int myPendingRequestId;
};

class DtReadFileCallback : public osgDB::Registry::ReadFileCallback
{
public:

   DtReadFileCallback(osgDB::Registry::ReadFileCallback* current)
      : osgDB::Registry::ReadFileCallback()
      , myLoadImages(false)
      , myCurrentReadFileCallback(current)
   {

   }

   virtual osgDB::ReaderWriter::ReadResult readImage(const std::string& filename, const osgDB::ReaderWriter::Options* options)
   {
      if (loadImages())
      {
         DtVerbose << "Reading Image: " << filename << std::endl;

         if (myCurrentReadFileCallback)
         {
            return myCurrentReadFileCallback->readImage(filename, options);
         }
         else
         {
            return osgDB::Registry::instance()->readImageImplementation(filename, options);
         }    
      }
      else
      {
         //Ignore images.  We don't need them.  However, create an empty one and set the filename for later
         boost::unordered_map<std::string, osg::ref_ptr<osg::Image> >::iterator iter = myMappedImages.find(filename);
         osg::ref_ptr<osg::Image> img;

         if (iter == myMappedImages.end())
         {
            img = new osg::Image;
            myMappedImages[filename] = img;

            DtFilename stripDown(filename.c_str());

            stripDown.stripPath();

            img->setFileName(stripDown.c_str());
         }
         else
         {
            img = iter->second;
         }

         //return img;
         return osgDB::ReaderWriter::ReadResult(img.get(), osgDB::ReaderWriter::ReadResult::FILE_NOT_HANDLED);
      }

   }

   virtual osgDB::ReaderWriter::ReadResult openArchive(
      const std::string& filename,osgDB::ReaderWriter::ArchiveStatus status, 
      unsigned int indexBlockSizeHint,
      const osgDB::ReaderWriter::Options* useObjectCache)
   {
      if (myCurrentReadFileCallback)
      {
         return myCurrentReadFileCallback->openArchive(filename,
            status, indexBlockSizeHint, useObjectCache);
      }
      else
      {
         return osgDB::Registry::instance()->openArchiveImplementation(filename,
            status, indexBlockSizeHint, useObjectCache);
      }
   }

   virtual osgDB::ReaderWriter::ReadResult readObject(
      const std::string& filename, const osgDB::ReaderWriter::Options* options)
   {
      if (myCurrentReadFileCallback)
      {
         return myCurrentReadFileCallback->readObject(filename, options);
      }
      else
      {
         return osgDB::Registry::instance()->readObjectImplementation(filename,
            options);
      }
   }

   virtual osgDB::ReaderWriter::ReadResult readHeightField(
      const std::string& filename, const osgDB::ReaderWriter::Options* options)
   {
      if (myCurrentReadFileCallback)
      {
         return myCurrentReadFileCallback->readHeightField(filename, options);
      }
      else
      {
         return osgDB::Registry::instance()->readHeightFieldImplementation(filename,
            options);
      }
   }

   virtual osgDB::ReaderWriter::ReadResult readShader(
      const std::string& filename, const osgDB::ReaderWriter::Options* options)
   {
      if (myCurrentReadFileCallback)
      {
         return myCurrentReadFileCallback->readShader(filename, options);
      }
      else
      {
         return osgDB::Registry::instance()->readShaderImplementation(filename,
            options);
      }
   }

   virtual osgDB::ReaderWriter::ReadResult readNode(const std::string& filename, const osgDB::ReaderWriter::Options* options)
   {
      osgDB::ReaderWriter::ReadResult readResult;

      if (myCurrentReadFileCallback)
      {
         readResult = myCurrentReadFileCallback->readNode(filename, options);
      }
      else
      {
         readResult = osgDB::Registry::instance()->readNodeImplementation(filename, options);
      }

      std::string className;

      if (readResult.getNode())
      {
         className = readResult.getNode()->className();

         readResult.getNode()->setUserData(new DtNodeUserData());

         DtVerbose << " Reading " << className << ": " << filename << std::endl;
      }
      else if (readResult.status() == osgDB::ReaderWriter::ReadResult::FILE_NOT_FOUND)
      {
         //DtVantageTerrainEngine::terrainEngine()->addToFilesNotFound(filename);
         //DtVantageTerrainEngine::terrainEngine()->updateDrawer();
      }

      return readResult;
   }

   virtual void setLoadImages(const bool& loadImages) { myLoadImages = loadImages; }

   virtual bool loadImages() const { return myLoadImages; }

protected:

   bool myLoadImages;

   virtual ~DtReadFileCallback() {}

protected:
   boost::unordered_map<std::string, osg::ref_ptr<osg::Image> >  myMappedImages;
   osg::ref_ptr<osgDB::Registry::ReadFileCallback> myCurrentReadFileCallback;
};

class DtTerrainAltitudeTable
{
public:
   typedef DtPoint Point;

   DtTerrainAltitudeTable(
      const osgEarth::Map* map, unsigned lod,
      double bias=30000, double factor=2);

   typedef std::vector<DtChord> ChordVector;

   void breakUpChord(const MAKVRinTerra::DtProj& proj, DtChord, ChordVector& chords);

   typedef std::pair<double,double> Segment;
   typedef std::set<Segment> SegmentSet;

protected:
   DtTerrainAltitudeTable(
      const osgEarth::TileKey& tilekey, const osgEarth::Map* map, unsigned lod,
      MAKVRinTerra::DtProj::CPtr,
      double bias, double factor);

   DtTerrainAltitudeTable(
      const osgEarth::TileKey& tilekey,
      const osg::HeightField* field,
      unsigned xmin, unsigned xmax, unsigned ymin, unsigned ymax,
      MAKVRinTerra::DtProj::CPtr,
      double bias, double factor);

   void removeSegments(const DtChord& chord, SegmentSet& set);

   void createBoundaries();

   void setMaxHeight();

   typedef boost::ptr_vector<DtTerrainAltitudeTable> SubCellVector;
   typedef std::vector<DtChord> BoundaryVector;

   osgEarth::TileKey myTileKey;
   MAKVRinTerra::DtProj::CPtr myProj;
   double myXmin, myXmax, myYmin, myYmax;
   BoundaryVector myBoundaries;
   double myMaxHeight;
   SubCellVector mySubcells;
   double myBias;
   double myFactor;
};