DtHierarchicalPagedLod.h

Go to the documentation of this file.

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


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

#include <boost/signals.hpp>
#include <boost/unordered_map.hpp>

#include <vrvCore/DtUniqueID.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#define DTHIERARCHICALPAGEDLOD_LOGGING 0

namespace makVrv
{
   class DtOsgCullVisitor;
   class DtOsgArticulatedModel;
   class DtModelDefinition;

   class DT_DLL_VRVOSG DtHierarchicalPagedLod : public DtFastGroup
   {
   public:

      typedef boost::unordered_map<DtUniqueID, DtSceneObject* > SceneObjectMap;

      DtHierarchicalPagedLod(DtDe& de, 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);

      inline int getNumChildrenPagedIn() { return myPagedInCount; }

      void increaseCountUpToParents();

      void decreaseCountUpToParents(int amount);

      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;

      inline float getTileRadius() { return myTileRadius; }

      boost::signal<void(osg::Group* page, osg::Node* child)> signal_childPagedIn;

      boost::signal<void(osg::Group* page, osg::Node* child)> signal_childAboutToPageOut;

   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;

      // Am I paged in + how many children are paged in
      // so a tile that has 4 paged in children would have a count of 5
      // a tile with no paged in children would have a count of 1
      // because of DtHierarchicalPagedLod::fileInRange
      // it looks like if the children are pagedIn, the parent is pagedIn
      // (but not always displayed)
      int myPagedInCount;

      DtDe& myDe;

      // The metaflight proxy objects are DtOsgArticulatedModels, they are put 
      // under a DtSceneObject so that they work when instancing is off
      // The DtSceneObject doesn't have the transform, the articulated model does
      // Maybe this can be eliminated
      SceneObjectMap mySceneObjs;

#if DTHIERARCHICALPAGEDLOD_LOGGING
      static int myHPLODRefCount;
#endif
   };
}