DtOsgTerrainPatchObject.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2015 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 <vrvOsg/DtTextureVisitor.h>
#include <vrvOsg/DtLightPointVisitor.h>
#include <vrvOsg/DtOsgEarthFeatureDataBroker.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvCore/DtMetaFileManager.h>

#include <boost/unordered_map.hpp>

namespace osgEarth
{
   class ElevationQuery;
   class MapNode;
}

namespace makVrv
{

   class DtDe;
   class DtTerrainPatchGroup;
   class DtOsgExtractedNodesLogic;
   
   class DT_DLL_VRVOSG DtOsgTerrainPatchObject : public DtTerrainPatchObject
   {
   public:
      DtOsgTerrainPatchObject(DtDe& de, DtUniqueID elementId);

      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 showLightPoints(bool show);

      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 void extractOceanNodes(const std::string& ruleset, bool isRegEx);
      
      virtual bool haveExtractedOcean() const;
     
      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;

      osgEarth::MapNode *mapNode();
      const osgEarth::MapNode *mapNode() const;

      void installOsgEarthFeatureDataCallback( const std::string& featureName,
         DtOsgEarthFeatureDataBroker::Callback* callback );

      virtual const DtTextureVisitor::TextureMap& foundTextures() const;

      virtual void setOsgEarthMaterialValues( float ambient, float diffuse, 
         float specular, float shininess );
      virtual void getOsgEarthMaterialValues( float& ambient, float& diffuse, 
         float& specular, float& shininess );

      virtual osg::ref_ptr<DtFastGroup> getOsgEarthModelsNode(){return myOsgEarthModelsNode;}

      DtMetaFileManager::LinkageValueVec& terrainPatchMetaFileFeatures();

      std::vector<DtVirtualBaseClass*>& terrainAttachments();

      void appendLighPoints(DtLightPointVisitor::LightPointNodeObsVec& osgLightPoints);

      virtual void setTerrainTreeScaleRandomization( bool isRandomized );

      virtual bool isTerrainTreeScaleRandomizationEnabled() const;

      virtual void setTerrainTreeMinScale( double minScale);

      virtual double terrainTreeMinScale() const;

      virtual void setTerrainTreeMaxScale( double maxScale);

      virtual double terrainTreeMaxScale() const;

      virtual void setTerrainTreeOrientationRandomization( bool isRandomized );

      virtual bool isTerrainTreeOrientationRandomizationEnabled() const;

      bool isDestructing();

      void useICO(bool enable);

   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 );

      virtual void setPerPixelLightingEnabled( bool setting );

      virtual void slot_perPixelLightingChanged( bool newVal );
      virtual void slot_usePixelShaderForOsgEarthModelsChanged();
      virtual void slot_postUpdate();
      virtual void setOsgEarthMaterial( float ambient, float diffuse, 
         float specular, float shininess );
      virtual void setOsgEarthMaterialOnNode( osg::Node& node, float ambient, float diffuse, 
         float specular, float shininess );
      virtual void setOsgEarthMaterialOnStateSet( osg::StateSet& ss, float ambient, float diffuse, 
         float specular, float shininess );

      virtual void slot_terrainPaged();

      //         demand if necessary.
      osgEarth::ElevationQuery* getOrCreateElevationQuery();

      // Installs a data broker and feature data processing callbacks.
      void installOsgEarthFeatureDataProcessors();

      // Sets up the osgEarth GeometryCompiler with custom defaults.
      void configureOsgEarthFeatureGeometryCompiler();

   protected:

  
      osg::ref_ptr<DtTerrainPatchGroup> myRoot;

      osg::ref_ptr<DtFastGroup> myTerrainGroup;

      osg::ref_ptr<osgEarth::MapNode> myMapNode;
      osg::ref_ptr<DtFastGroup> myOsgEarthModelsNode;

      DtOsgTerrainOverlayManager myOverlayManager;
      DtTextureVisitor::TextureMap myFoundTextureMap;
      DtLightPointVisitor::LightPointNodeObsVec myFoundLightPointsVec;
      bool myGlobalFlag;
      bool myHaveExtractedOcean;
      bool myPerPixelLightingChanged;
      volatile bool myTerrainPagedThisFrame;
      bool myPendingPerPixelLightingValue;
      bool myOsgEarthMaterialChanged;
      float myPendingOsgEarthMaterialAmbient;
      float myPendingOsgEarthMaterialDiffuse;
      float myPendingOsgEarthMaterialSpecular;
      float myPendingOsgEarthMaterialShininess;
      DtSignalConnectionManager mySignals;

      // List of node pointers that have meta data associated with them
      DtMetaFileManager::LinkageValueVec myTerrainPatchMetaFileFeatures;
      // Vector of node with .meta file info associated with them 
      // on this terrain so they can be deleted on page destruction
      std::vector<DtVirtualBaseClass*> myTerrainAttachments;

      osgEarth::ElevationQuery* myElevationQuery;

      osg::ref_ptr<DtOsgEarthFeatureDataBroker> myOsgEarthFeatureDataBroker;

      bool myShowLightPoints;

      bool myTerrainTreeScaleRandomizationEnabled;
      float myTerrainTreeMinScale;
      float myTerrainTreeMaxScale;
      bool myTerrainTreeOrientationRandomizationEnabled;

      bool myDestructing;

      DtOsgExtractedNodesLogic* myExtractedNodesLogic;
      friend class DtOsgExtractedNodesLogic;
   };
}