boundingNodeInfo.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/vantageTerrainImplementationUtil.h>
#include <geometry/sphere.h>
#include <boost/shared_ptr.hpp>
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>
#include <tbb/spin_mutex.h>
#include <osg/Matrix>
#include <vector>

//Stores information about a paged out bounding volume.
struct DT_DLL_vantageTerrainImplementation DtNodeBoundingInfo
{
   DtNodeBoundingInfo(DtSphere boundingSphere, std::string filename, bool known=false)
      : myBoundingSphere(boundingSphere)
      , myOriginalBoundingSphere(boundingSphere)
      , myFilename(filename)
   {
   }

   virtual void expandExtent(DtExtent& ext) const
   {
      ext.expandToInclude(extent());
   }

   virtual DtExtent extent() const
   {
      return extentOfSphere(myBoundingSphere);
   }

   virtual std::string filename() const
   {
      return myFilename;
   }

   DtSphere myBoundingSphere;
   const DtSphere myOriginalBoundingSphere;
   const std::string myFilename;
};

struct DT_DLL_vantageTerrainImplementation DtPagedNodeStatus
{
   DtPagedNodeStatus(
      DtNodeBoundingInfo boundingInfo,
      unsigned int numTriangles,
      DtTerrainIntersectIDType lastUsed = 0)
      : myBoundingInfo(boundingInfo)
      , myLastUsed(lastUsed)
      , myNumTriangles(numTriangles)
      , myPendingRemoval(false)
   {
   }

   const DtNodeBoundingInfo myBoundingInfo;
   const unsigned int myNumTriangles;

   bool myPendingRemoval;

   void updateLastUsed(DtTerrainIntersectIDType lastUsed)
   {
      tbb::spin_mutex::scoped_lock lock(myMutex);
      if (lastUsed > myLastUsed)
      {
         myLastUsed = lastUsed;
      }
   }

   DtTerrainIntersectIDType lastUsed() const
   {
      tbb::spin_mutex::scoped_lock lock(myMutex);
      return myLastUsed;
   }

protected:
   mutable tbb::spin_mutex myMutex;
   DtTerrainIntersectIDType myLastUsed;
};

typedef DtBoost::shared_ptr<DtNodeBoundingInfo> DtNodeBoundingInfoPtr;
typedef DtBoost::shared_ptr<DtPagedNodeStatus>  DtPagedNodeStatusPtr;

inline std::size_t hash_value(const DtNodeBoundingInfoPtr& p)
{
   boost::hash<DtNodeBoundingInfo*> hasher;
   return hasher(p.get());
}

struct DT_DLL_vantageTerrainImplementation DtPagedInExtendInfo
{
   DtPagedInExtendInfo(const DtNodeBoundingInfoPtr& nodeBoundingInfoPtr, const osg::Matrix& matrix):
      myNodeBoundingInfoPtr(nodeBoundingInfoPtr),
      myMatrix(matrix)
   {
   }
   DtPagedInExtendInfo(const DtPagedInExtendInfo& rh) :
      myNodeBoundingInfoPtr(rh.myNodeBoundingInfoPtr),
      myMatrix(rh.myMatrix)
   {
      for (size_t i = 0; i < rh.myAssociatedDrawable.size(); i++)
      {
         myAssociatedDrawable.push_back(rh.myAssociatedDrawable[i]);
      }
      for (size_t i = 0; i < rh.myNbTriangles.size(); i++)
      {
         myNbTriangles.push_back(rh.myNbTriangles[i]);
      }
   }
   DtPagedInExtendInfo()
   {
   }

public:
   DtNodeBoundingInfoPtr myNodeBoundingInfoPtr;
   osg::Matrix myMatrix;
   std::vector<DtNodeId> myAssociatedDrawable;
   std::vector<size_t>   myAssociatedDrawableId;
   std::vector<size_t>  myNbTriangles;
};

typedef std::list<DtNodeBoundingInfoPtr>                      DtNodeBoundingInfoList;
typedef boost::unordered_set<DtNodeBoundingInfoPtr>           DtNodeBoundingInfoSet;
typedef boost::unordered_map<DtNodeId, DtNodeBoundingInfoPtr> DtNodeBoundingInfoMap;
typedef boost::unordered_map<DtNodeId, DtPagedInExtendInfo>   DtNodeBoundingExtendedInfoMap;
typedef boost::unordered_map<DtNodeId, DtPagedNodeStatusPtr>  DtPagedNodeStatusMap;