DtTerrainPatchObject.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtTreeRecord.h>
#include <vrvCore/DtLightPointManager.h>

#include <vrvUtil/DtVirtualBaseClass.h>

#include <matrix/vlVector.h>

#include <vrvUtil/signalslib.h>

#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 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 extractSpeedTreeNodes(const std::string& rule, bool isRegEx, const std::string& modelDefinition) = 0;

      virtual void realizeExtractedSpeedTrees(const DtVectorTreeRecords& trees) = 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 void setIsMinimapOnly(bool isForMinimap) = 0;
      virtual bool isMinimapOnly() const = 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;

      virtual void setMaxPagedLODs(unsigned int maxPagedLODs) = 0;

      virtual void postExtractionProcessing() = 0;

      virtual void toggleVisibility(bool visibility) = 0;

   protected:

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

   };

   class DT_DLL_VRVCORE DtTerrainPatchObjectSignaler : public DtVirtualBaseClass
   {
   public:

      static DtTerrainPatchObjectSignaler& instance(DtDe&);

      virtual ~DtTerrainPatchObjectSignaler();

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

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

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

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

      boost::signalslib::signal<void(DtTerrainPatchObject&, bool extracted)> signal_oceanNodesExtracted;

      boost::signalslib::signal<void(DtTerrainPatchObject&)> signal_osgEarthMapNodeFound;

      boost::signalslib::signal<void(const DtVectorTreeRecords&, DtTerrainPatchObject&)> signal_realizeSpeedTreesFromRecords;

   protected:
      DtTerrainPatchObjectSignaler();
   };
}