include/vrvOsg/DtHierarchicalPagedLod.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2011 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile:  $ $Revision:  $ $State:  $
******************************************************************************/


#pragma once
#include <vrvOsg/vrvOsg.h>
#include <vrvOsg/DtFastGroup.h>
#include <osg/Vec3>
#include <osg/MatrixTransform>
#include <osgDB/Options>

namespace makVrv
{
   class DtOsgCullVisitor;

   class DT_DLL_VRVOSG DtHierarchicalPagedLod : public DtFastGroup
   {
   public:

      DtHierarchicalPagedLod(const std::string& filename, 
         float distanceNear, float distanceFar, float tileRadius, 
         float childTileRadius, const osg::Vec3d& fileCenter, 
         const osg::Vec3d& childrenCenter, bool sparseChildren,
         bool substitutiveChildren, const osg::Matrixd& fileTranslation,
         osgDB::Options* options);

      virtual ~DtHierarchicalPagedLod();

      virtual const char* className() const { return "DtHierarchicalPagedLod"; }

      void addChildHierarchy(DtHierarchicalPagedLod* child);

      virtual void traverse(osg::NodeVisitor& nv);

      virtual void traverseAll(osg::NodeVisitor& nv);

      virtual void traverseActive(osg::NodeVisitor& nv);
     
      virtual void cullActive(osg::NodeVisitor& nv);

      void cullActive2D(DtOsgCullVisitor& nv);

      void cullActive3D(osg::NodeVisitor& nv);

      virtual osg::BoundingSphere computeBound() const;

      virtual void traverseFile(osg::NodeVisitor& nv,float distance );    
      
      virtual void traverseChildren(osg::NodeVisitor& nv);

      virtual bool fileInRange(float distance) const;

      virtual float fileRangeDistance(osg::NodeVisitor& nv) const;

      virtual float childRangeDistance( osg::NodeVisitor& nv ) const;
      
      void pageInFile(osg::NodeVisitor& nv, float distance);

      void pageOutFile(int lastCullTime, osg::NodeList& toRemove);

      bool fileNotLoaded() const;

      bool fileIsPaging() const;

      bool fileIsLoaded() const;

      virtual bool fileInChildRange(float distance) const;

      void pageInChildren(osg::NodeVisitor& nv, float distance);

      void pageOutChildren(int lastCullTime, osg::NodeList& toRemove);

      bool childrenLoaded() const;

      osg::ref_ptr<osg::Node> fileNode();

      virtual bool addPagedInChild(Node* child);

      virtual void adjustLOD( Node* child);

      float fileRangeCullDistance2D(DtOsgCullVisitor& nv );

      bool fileInRange2D( float distance, float cull);

      float childRangeCullDistance2D(DtOsgCullVisitor& nv );

      bool fileInChildRange2D( float cull, float lod );

      void setThreadSafeRefUnref(bool threadSafe);

      virtual void resizeGLObjectBuffers(unsigned int maxSize);

      virtual void releaseGLObjects(osg::State* state) const;

      virtual std::string fileName() const;

      virtual const std::vector<osg::ref_ptr<DtHierarchicalPagedLod> >& children() const;

      virtual const osg::Matrix& fileTranslation() const;

   protected:

      enum FileState
      {
         NotLoaded = 0,
         Paging,
         Loaded
      };

      class DT_DLL_VRVOSG PagedFileRoot : public osg::MatrixTransform
      {
      public:
         PagedFileRoot(DtHierarchicalPagedLod& parent, const osg::Matrixd& m)
         : osg::MatrixTransform(m)
         , myParent(parent)
         {
            _parents.push_back(&parent);
         }
         
         //Override Add child to inform DtHierarchicalPagedLod of page in.
         virtual bool addChild( Node *child )
         {
            return myParent.addPagedInChild(child);          
         }
         DtHierarchicalPagedLod& myParent;
      };
      
      osg::Vec3d myFileCenter;
      osg::Vec3d myChildrenCenter;

      const float myRangeNear;
      const float myRangeFar;
      const float myTileRadius;
      const float myChildTileRadius;
      const bool myChildrenAreSparse;
      const bool myChildrenAreSubstitutive;

      volatile int myCullTracking;
      std::string myFileName;
      FileState myFileState;
      osg::ref_ptr<PagedFileRoot> myFileRoot;
      std::vector<osg::ref_ptr<DtHierarchicalPagedLod> > myChildren;
      osg::ref_ptr<osg::Referenced> myPageRef;
      osg::ref_ptr<osgDB::Options> myOptions;
   };
}