pagedNode2Visitors.h

Go to the documentation of this file.

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

#pragma once

#include <vantageTerrainImplementation/vantageTerrainImplementationDefines.h>
#include <vantageTerrainImplementation/vantageTerrainImplementation.h>
#include <vantageTerrainImplementation/vantageTerrainImplementationUtil.h>
#include <vantageTerrainImplementation/boundingVolumeTerrainSourcePager.h>
#include <vantageTerrainImplementation/boundingNodeInfo.h>
#include <terrainInterface/terrainPagingGeometry.h>
#include <terrainInterface/terrainPagingChord.h>

#include <osg/NodeVisitor>
#include <osg/ref_ptr>
#include <osg/Node>
#include <osg/LightSource>
#include <osgEarth/PagedNode>

#include <geometry/chord.h>

#include <set>
#include <vector>
#include <unordered_set>


typedef std::vector<osg::Matrix> MatrixStack;

class DT_DLL_vantageTerrainImplementation DtTerrainIsPagedNode2Visitor : public osg::NodeVisitor
{
public:

   DtTerrainIsPagedNode2Visitor();
   virtual ~DtTerrainIsPagedNode2Visitor();

   virtual void apply(osg::Node& node);

   virtual const bool encounteredPagedNode2() const;

protected:

   bool myEncounteredPagedNode2;
};


class DT_DLL_vantageTerrainImplementation DtScopedNodeStackPoopPusher
{
public:
   DtScopedNodeStackPoopPusher(std::stack <osg::ref_ptr<osg::Node> >& stack)
      : myStack(stack)
      , myTmpTop(myStack.top())
   {
      myStack.pop();
   }
   virtual ~DtScopedNodeStackPoopPusher()
   {
      myStack.push(myTmpTop);
   }
   std::stack <osg::ref_ptr<osg::Node> >& myStack;
   osg::ref_ptr<osg::Node> myTmpTop;
};

class DT_DLL_vantageTerrainImplementation PagedNode2LoadDataVisitor : public DtGeometryPageInVisitor
{
public:
   PagedNode2LoadDataVisitor(const Coordinate_System* cs, DtTerrainPagingGeometryPtr geometry);

   bool isFullyLoaded() const;
   void apply(osg::Node& node);
   void apply(osgEarth::PagedNode2& pagedNode);
   void apply(osg::PagedLOD& node);
   void apply(osg::LightSource& ls);

   void manualUpdate();
   void reset();
   size_t count() { return myCount;  }

   void setNodePathHint(const std::stack <osg::ref_ptr<osg::Node> >& hint)
   {
      myNodePathHint = hint;
   }
protected:

   bool myFullyLoaded;
   std::set < osg::ref_ptr < osgEarth::PagingManager> > myPagingManagers;

   std::set< std::string > myLoadingList;
   std::stack <osg::ref_ptr<osg::Node> > myNodePathHint;
   size_t myCount;
};


class DT_DLL_vantageTerrainImplementation PagedNode2CollectTrianglesVisitor : public DtGeometryPageInVisitor
{
public:
   PagedNode2CollectTrianglesVisitor(const Coordinate_System* cs, DtTerrainPagingGeometryPtr geometry, const DrawableList& existingDrawable, DrawableMap& newDrawable,
      DtNodeBoundingExtendedInfoMap& pagedInBoundingMap, const NodePagingRecordMap& pagedInNodes);

   void apply(osg::Node& node);
   void apply(osgEarth::PagedNode2& pagedNode);
   void apply(osg::Drawable& drawable);
   void apply(osg::PagedLOD& node);
   void apply(osg::LightSource& ls);


protected:

   struct CollectTriangles
   {
      CollectTriangles()
      {
         verts = new osg::Vec3Array();
      }
#if OSG_VERSION_LESS_THAN(3,5,6)
      inline void operator () (const osg::Vec3& v1, const osg::Vec3& v2, const osg::Vec3& v3, bool treatVertexDataAsTemporary)
#else
      inline void operator () (const osg::Vec3& v1, const osg::Vec3& v2, const osg::Vec3& v3)
#endif
      {
         verts->push_back(v1);
         verts->push_back(v2);
         verts->push_back(v3);
      }
      osg::ref_ptr< osg::Vec3Array > verts;
   };

   inline void pushPagedNode2(osgEarth::PagedNode2& pagedNode2) { myPagedNode2Stack.push_back(&pagedNode2); }
   inline void popPagedNode2() { myPagedNode2Stack.pop_back(); }

   typedef std::vector<DtNodeId> PagedNode2Stack;
   PagedNode2Stack myPagedNode2Stack;
   const DrawableList& myExistingDrawable;
   DrawableMap& myNewDrawable;
   DtNodeBoundingExtendedInfoMap& myPagedInBoundingMap;
   const NodePagingRecordMap& myPagedInNodes;
};

class DT_DLL_vantageTerrainImplementation PagedNode2UnLoadDataVisitor : public osg::NodeVisitor
{
public:
   PagedNode2UnLoadDataVisitor(osg::ref_ptr<osg::Node> pagedNode2);

   void apply(osg::Node& node);
   void manualUpdate();
   bool isUnloaded();

protected:

   osg::ref_ptr<osg::Node> myPagedNode2ToUnload;
   bool myEndTraversal;
   bool myPagedNode2encountered;
   std::set < osg::ref_ptr < osgEarth::PagingManager> > myPagingManagers;
};

class DT_DLL_vantageTerrainImplementation PagedNode2ActiveVisitor : public DtBoundingVolumeActivePageVisitor
{
public:
   using DtBoundingVolumeActivePageVisitor::apply;

   PagedNode2ActiveVisitor(const NodePagingRecordMap& pagedInNode, const NodePagingRecordMap& emptyPagedInNode, NodePagingRecordMap& pagedOutNodes);
   void apply(osg::Node& node);
   void apply(osgEarth::PagedNode2& pagedNode);
   void apply(osg::LightSource& ls);

protected:

   bool addToPagedOutVolumesList(DtNodeBoundingInfoPtr pagedOutArea);
   bool addToPagedOutVolumesList(DtNodeBoundingInfo* pagedOutArea);

   const NodePagingRecordMap& myPagedInNodes;
   NodePagingRecordMap& myPagedNode2OutNodes;
   const NodePagingRecordMap& myEmptyPagedInNodes;
   std::set< osg::Node* > _traversedNodes;
   int _level;
};

class DT_DLL_vantageTerrainImplementation DtReversePagedNode2PageManagerFinderVisitor : public osg::NodeVisitor
{
public:
   DtReversePagedNode2PageManagerFinderVisitor(osg::ref_ptr<osg::Node> end);

   void apply(osg::Node& node);
   void apply(osgEarth::PagedNode2& pagedNode);


   void manualUpdate();
   const std::stack< osg::ref_ptr < osg::Node> >& nodesTraveled() const
   {
      return myNodesTraveledInReverse;
   }

public:
   std::set < osg::ref_ptr < osgEarth::PagingManager> > myPagingManagers;
   std::stack < osg::ref_ptr < osg::Node> > myNodesTraveledInReverse;

};

size_t getDrawableHash(const osg::Drawable& drawable, const osg::Matrix& matrix);