DtOsgTerrainPatchObject.h

Go to the documentation of this file.

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


#pragma once
#include <vrvOsg/vrvOsg.h>
#include <vrvOsg/DtOsgTerrainOverlayManager.h>
#include <vrvCore/DtTerrainPatchObject.h>
#include <vrvOsg/DtFastGroup.h>
#include <osg/ref_ptr>

namespace osgEarth
{
   class MapNode;
}

namespace osgEarth
{
   namespace Util
   {
      class ElevationManager;
   }
}

namespace makVrv
{

   class DtDe;
   class DtTerrainPatchGroup;

   class DT_DLL_VRVOSG DtOsgTerrainPatchObject : public DtTerrainPatchObject
   {
   public:

      DtOsgTerrainPatchObject(DtDe& de, DtUniqueID id);

      virtual ~DtOsgTerrainPatchObject();

      //

      virtual void setTerrainDefinition(const std::string& modelDefinitionName);

      virtual void enableOverlay(int type, const std::string& definition);

      virtual void disableOverlay(int type);

      virtual void disableAllOverlays();

      virtual void setOverlayScale(int type, double x, double y);

      virtual void setWrapMode(int type, int);

      virtual void setBlendMode(int type, int);

      virtual void setOverlayOffset(int type, double x, double y);

      virtual void setLayerEnabled(const std::string& rule, bool status);

      virtual void setRasterLayerPosition(int type, int pos);

      //

      virtual std::string overlayDefinition(int type);

      virtual std::vector<double> overlayScale(int type);
      virtual std::vector<double> overlayOffset(int type);
      virtual DtTerrainOverlayOperation defaultOverlay(int type);
      virtual DtTerrainOverlayOperation currentOverlay(int type);

      virtual void getBoundingBoxMinMax(DtVector& min, DtVector& max) const;

      virtual void getTerrainExtents(DtVector& nw, DtVector& ne, DtVector& sw, DtVector& se) const;

      virtual DtVector getDatabaseOrigin() const;
      
      virtual void getBoundingBoxCenter(float& x, float& y, float& z) const;

      //Get the terrain group node.
      osg::Group* terrainGroupNode();

      virtual void extractNodes(const std::string& ruleset, bool isRegEx);
     
      virtual int countNodes(const std::string& rule) const;

      virtual bool getExtractedNodePosition(const std::string& rule, 
         unsigned int index, double& x, double& y, double& z) const;

      virtual bool getExtractedNodeOrientation( const std::string& rule, 
         unsigned int index, double& x, double& y, double& z, double& w) const;

      virtual void moveNode(DtSceneObject* object,
         DtModel* model,const std::string& rule, unsigned int index);

      virtual osg::Node* findNode(const std::string& rule, unsigned int index);

      virtual bool isGlobalScaleTerrain() const;

      virtual bool getTerrainIntersection(double x, double y, double z,
         double vx, double vy, double vz, double& retX, double& retY, double& retZ );
         
      virtual void clearElevationCache();

      bool isOsgEarth() const
      {
         return myMapNode != 0;
      }

   private:
      DtOsgTerrainPatchObject(const DtOsgTerrainPatchObject&);
      DtOsgTerrainPatchObject& operator=(const DtOsgTerrainPatchObject&);

   protected:

      void removeChildNodesAndCache();

      static void graphBoundingBox(const osg::Node* node, osg::BoundingBox &bbox);

      //Remove the node from it's parent, and if the parent has no other
      //Children remove it from it's parent too recursively.
      void removeEmptyParent(osg::Node* node);
      void updateBounds();

      virtual bool getElevation(double lonRadians, double latRadians,
         double& retElevation );
      
   protected:

      struct ExtractedNode
      {
         osg::Vec3 location;
         osg::Vec3 scale;
         osg::Quat orientation;
         osg::Quat orientationScale;
         osg::ref_ptr<osg::Node> node;
         osg::Node::ParentList parents;
      };


      osg::ref_ptr<DtTerrainPatchGroup> myRoot;

      osg::ref_ptr<DtFastGroup> myTerrainGroup;

      osgEarth::Util::ElevationManager* myElevationManager;
      osgEarth::MapNode* myMapNode;

      typedef std::vector<ExtractedNode> NodeList;
      typedef std::map<std::string, NodeList > ExtractedNodeListMap;
      ExtractedNodeListMap myExtractedNodes;
      
      DtOsgTerrainOverlayManager myOverlayManager;

      bool myGlobalFlag;
   };   
}