DtTerrain.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/DtForest.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <matrix/vlVector.h>

#include <makArchives/DtTerrainRecord.h>

#include <boost/signal.hpp>
#include <boost/shared_ptr.hpp>

#include <string>
#include <list>
#include <vector>

namespace makArchives 
{ 
   class DtFeatureLayerRecord;
   class DtOceanLayerRecord;
   class DtTerrainPatchRecord;
}

namespace makVrv
{
   class DtBuoyOrBeaconFacade;
   class DtDe;
   class DtFeature;
   class DtFeatureLayer;
   class DtModelAgent;
   class DtOceanLayer;
   class DtDynamicFeatureLayer;
   class DtProp;
   class DtTerrainPatch;
   class DtTerrainPatchObjectAgent;
   class DtTerrainPatchObject;
   class DtTerrainSignaler;
   class DtTexturedQuad;
   class DtBuoyBeaconLayer;
   class DtStreamedFeatureLayer;
   class DtNavigationLightManager;
   class DtNavigationFeatureManager;
   class DtLightPointUpdater;

   class DT_DLL_VRVCORE DtTerrain : private DtSignalConnectionManager
   {

   public:

      typedef std::list<DtTerrainPatch*> TerrainPatches;
      typedef std::list<DtFeatureLayer*> FeatureLayers;
      typedef std::list<DtOceanLayer*> OceanLayers;

      typedef std::map<int, makArchives::DtTerrainOperationRecord> TerrainOperationsMap;

      DtTerrain(DtDe& de, DtAgentManagerInterface& sceneManagerInterface);

      virtual ~DtTerrain();

      void clear(bool reload=false);



      bool globalScaleTerrain() const;

      void updateGlobalScaleTerrain();

      virtual void getRecord(makArchives::DtTerrainRecord& rec);

      virtual void setFromRecord(const makArchives::DtTerrainRecord& rec, bool clearFirst=true);

      virtual void reloadTerrain();




      virtual DtTerrainPatch& addTerrainPatch(const makArchives::DtTerrainPatchRecord& rec);

      virtual DtTerrainPatch& addTerrainPatch(const std::string& terrainDefinitionName, bool minimapOnly=false);

      virtual DtTerrainPatch* findTerrainPatch(const std::string& terrainDefinitionName);

      virtual DtTerrainPatch* findTerrainPatch(DtUniqueID id);

      virtual bool removeTerrainPatch(const std::string& terrainDefinitionName);

      const TerrainPatches& terrainPatches() const ;

      TerrainPatches& terrainPatches();

      bool lightPointsEnabled() const;



      virtual const TerrainOperationsMap& terrainOperationsMap() const;




      virtual DtFeatureLayer& addFeatureLayer(const makArchives::DtFeatureLayerRecord& rec, 
         makArchives::DtTerrainOperationRecord::TargetApplication target = 
         makArchives::DtTerrainOperationRecord::VisualizationAndSimulation);

      virtual DtFeatureLayer& addFeatureLayer(const std::string& featureLayerFilename, 
         makArchives::DtTerrainOperationRecord::TargetApplication target = 
         makArchives::DtTerrainOperationRecord::VisualizationAndSimulation );

      virtual void removeFeatureLayer(const std::string& featureLayerFilename);

      virtual const FeatureLayers& featureLayers() const;

      virtual FeatureLayers& featureLayers();

      virtual DtFeatureLayer* findFeatureLayer(const std::string& featureLayerFilename);

      virtual DtStreamedFeatureLayer& streamedFeatureLayer();

      virtual DtBuoyBeaconLayer& buoyBeaconLayer();

      virtual DtDynamicFeatureLayer& dynamicFeatureLayer();

      virtual DtNavigationLightManager& navigationLightManager();

      virtual DtNavigationFeatureManager& navigationDaymarkManager();

      virtual DtNavigationFeatureManager& navigationTopmarkManager();




      virtual DtOceanLayer& addOceanLayer( const makArchives::DtOceanLayerRecord& rec );

       virtual DtOceanLayer& addOceanLayer( const std::string& layerName );

      virtual void removeOceanLayer( const std::string& layerName );

      virtual const OceanLayers& oceanLayers() const;

      virtual OceanLayers& oceanLayers();

      virtual DtOceanLayer* findOceanLayer( const std::string& layerName );

      virtual void onOceanNodesExtracted( DtTerrainPatchObject& patchObject );



      std::string generatePropName(const std::string& propType);




      virtual DtForest& forest();

      bool isPropNameUsed(const std::string& propName) const;

      virtual bool getTerrainIntersection(double x, double y, double z,
         double upX, double upY, double upZ, double& retX, double& retY, 
         double& retZ );
         
      virtual void clearElevationCache();



      virtual bool exportTerrainAndProps(const std::string&);


      virtual const std::string* findOptionalParameter(const std::string& name) const;

      virtual void setOptionalParameter(const std::string& name, const std::string& value);

      virtual void setOptionalParameters(const makArchives::DtTerrainRecord::OptionalParameterMap&);

      virtual void removeOptionalParameter(const std::string& name);

      const makArchives::DtTerrainRecord::OptionalParameterMap& optionalParameters() const;

      virtual const std::string& description();

      virtual void setDescription(const std::string& description);

      virtual bool useICO() const;

      virtual void setUseICO(bool flag);

      virtual unsigned int maxPagedLODs() const;

      virtual void setMaxPagedLODs( unsigned int maxPagedLODs );

      virtual bool reloadingTerrain() { return myReloadingTerrain;}

   protected:

      void executeTerrainOperation(const makArchives::DtTerrainOperationRecord& operation, 
         const makArchives::DtTerrainRecord& terrainRec);

      void addTerrainOperationRecord(const makArchives::DtTerrainOperationRecord& operation);

      void removeTerrainOperationRecord( const makArchives::DtTerrainOperationRecord& operation);

      void removeTerrainOperationRecord(int id);

      void clearTerrainOperations();

      void slot_handleIsDayChanged(bool isDay);

      virtual bool checkIfTerrainOperationRecordsMatch
         (const makArchives::DtTerrainOperationRecord& left,
         const makArchives::DtTerrainOperationRecord& right);

      virtual void connectForestAndOceanSignals(void);

   protected:
      typedef std::map<std::string,int> PropNameMap;

      DtDe& myDe;
      DtTerrainSignaler& mySignaler;
      DtAgentManagerInterface& myAgentManagerInterface;

      TerrainPatches myTerrainPatches;
      FeatureLayers myFeatureLayers;
      OceanLayers myOceanLayers;
      DtForest * myForest;
      DtBuoyBeaconLayer* myBuoyLayer;
      DtStreamedFeatureLayer* myStreamedFeatureLayer;
      DtDynamicFeatureLayer* myDynamicFeatureLayer;
      DtNavigationLightManager* myNavigationLightManager;
      DtNavigationFeatureManager* myNavigationDaymarkManager;
      DtNavigationFeatureManager* myNavigationTopmarkManager;
            
      TerrainOperationsMap myTerrainOperationsMap;
      int myNextTerrainOperationId;
      bool myGlobalScaleFlag;
            
      PropNameMap myPropNameMap;

      makArchives::DtTerrainRecord::OptionalParameterMap myOptionalParameters;
      makArchives::DtTerrainRecord::GenericRecords myGenericRecords;

      std::string myDescription;

      bool myUseICO;
      unsigned int myMaxPagedLODs;

      bool myReloadingTerrain;

      DtTexturedQuad* myLogo;
   };

   class DT_DLL_VRVCORE DtTerrainSignaler : public DtVirtualBaseClass
   {
   public:

      static DtTerrainSignaler& instance(DtDe& de);

      virtual ~DtTerrainSignaler();

      //@name Signals

      boost::signal< void (const DtTerrainPatch&) > signal_terrainPatchAdded;

      boost::signal< void (const DtTerrainPatch&) > signal_terrainPatchToBeDeleted;

      boost::signal< void (const DtFeatureLayer&) > signal_featureLayerAdded;

      boost::signal< void (const DtFeatureLayer&) > signal_featureLayerToBeDeleted;

      boost::signal< void (const DtOceanLayer&) > signal_oceanLayerAdded;

      boost::signal< void (const DtOceanLayer&) > signal_oceanLayerToBeDeleted;

      boost::signal< void(const std::string&) > signal_oceanLayerDeleted;

      boost::signal< void (const DtOceanLayer&, double) > signal_oceanLayerSeaLevelChanged;

      boost::signal< void (const DtOceanLayer&, int) > signal_oceanLayerLodRangeChanged;

      boost::signal<void (bool reload) > signal_terrainToBeCleared;

      boost::signal< void () > signal_terrainCleared;

      boost::signal< void (DtProp& prop) > signal_propCreated;

      boost::signal< void (const DtProp& prop) > signal_propAboutToBeDestroyed;

      boost::signal< void (DtBuoyOrBeaconFacade& buoy, 
         const DtVector& initialPosition) > signal_buoyOrBeaconCreated;

      boost::signal< void (const DtBuoyOrBeaconFacade& buoy) > 
         signal_buoyOrBeaconAboutToBeDestroyed;

      boost::signal< void (const DtProp& prop, double x, double y, double z) > 
         signal_propPositionAboutToChange;

      boost::signal< void (const DtProp& prop, double x, double y, double z, double w) > signal_propOrientationAboutToChange;

      boost::signal< void (const DtFeature&) > signal_featureAdded;

      boost::signal< void (const DtFeature&) > signal_featureToBeDeleted;

      boost::signal< void(int id, const makArchives::DtTerrainOperationRecord& rec) > signal_terrainOperationAdded;

      boost::signal< void(int id) > signal_terrainOperationRemoved;

      boost::signal< void(bool) > signal_terrainIsGlobalScaleChanged;


   protected:
      DtTerrainSignaler();
   };


   class DT_DLL_VRVCORE DtTerrainCreator : public DtVirtualBaseClass
   {

   public:
      static DtTerrainCreator& instance(DtDe& de);

      static void registerInstance(DtDe& de, DtTerrainCreator* instance);     
      
      virtual DtTerrain* create( DtDe& de, 
         DtAgentManagerInterface& agentManager );
   };

}