DtTerrainPatchObject.h

Go to the documentation of this file.

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


#ifndef DtTerrainPatchObject_H_
#define DtTerrainPatchObject_H_

#include <vrvCore/vrvCore.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvCore/DtUniqueID.h>

#include <matrix/vlVector.h>
#include <boost/signals.hpp>
#include <string>



namespace makVrv
{
   class DtDe;
   class DtForestObject;
   class DtTerrainOverlayOperation;
   class DtSceneObject;
   class DtModel;

   class DT_DLL_VRVCORE DtTerrainPatchObject
   {

   public:

      static const double TheEarthRadius;

      DtTerrainPatchObject(DtDe& de, DtUniqueID id);

      virtual ~DtTerrainPatchObject();

      //@ name Driver-bound methods:

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

      const std::string& terrainDefinitionName() const;

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

      virtual void disableOverlay(int type) = 0;

      virtual void disableAllOverlays() = 0;

      virtual void showLightPoints(bool show) = 0;

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

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

      virtual void setWrapMode(int type, int clamp) = 0;

      virtual void setBlendMode(int type, int clamp) = 0;

      virtual void setRasterLayerPosition(int type, int pos) = 0;

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

      virtual void extractNodes(const std::string& rule, bool isRegEx) = 0;

      virtual void extractOceanNodes(const std::string& rule, bool isRegEx) = 0;

      virtual void setTerrainTreeScaleRandomization( bool isRandomized ) = 0;
      
      virtual void setTerrainTreeMinScale( double minScale) = 0;
      
      virtual void setTerrainTreeMaxScale( double maxScale) = 0;
      
      virtual void setTerrainTreeOrientationRandomization( bool isRandomized ) = 0;


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

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

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

      virtual DtVector getDatabaseOrigin() const = 0;

      virtual int countNodes(const std::string& rule) const = 0;

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

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

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

     virtual DtUniqueID uniqueID() const;

     virtual bool isGlobalScaleTerrain() const = 0;

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

      virtual void clearElevationCache() = 0;
      
      virtual void useICO(bool enable) = 0;

   protected:

      DtDe& myDe;
      DtUniqueID myUniqueID;
      std::string myTerrainDefinitionName;

   };

   class DT_DLL_VRVCORE DtTerrainPatchObjectSignaler : public DtVirtualBaseClass
   {
   public:

      static DtTerrainPatchObjectSignaler& instance(DtDe&);

      virtual ~DtTerrainPatchObjectSignaler();

      boost::signal<void (DtTerrainPatchObject&)> signal_terrainPatchCreated;

      boost::signal<void (DtTerrainPatchObject&)> signal_terrainDataChanged;

      boost::signal<void (DtTerrainPatchObject&)> signal_terrainPatchAboutToBeDeleted;

      boost::signal<void (DtTerrainPatchObject&,const std::string& rule, std::vector<std::string>)> signal_nodesExtracted;

      boost::signal<void (DtTerrainPatchObject&)> signal_oceanNodesExtracted;

   protected:
      DtTerrainPatchObjectSignaler();
   };
}

#endif