DtTerrainEditorLogic.h

Go to the documentation of this file.

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


#pragma once

#include<vrvTerrainEditor/vrvTerrainEditor.h>
#include<vrvTerrainEditor/DtTerrainEditorInterface.h> 
#include <osgEarth/MapCallback>
#include <osgEarth/GeoData>

#include <osgEarth/FeatureModelLayer> // FIXME: Remove me once FeatureModelLayerVector typedef is in osgEarth
#include <osgEarthAerodromes/AerodromeLayer> // FIXME: Remove me once AerodromeLayerVector typedef is in osgEarth

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtUnicode.h>
#include <osg/observer_ptr>

// Class Forward Declarations
namespace osgEarth
{
   class MapNode;
   class Layer;
   class Extension;
   class VisibleLayer;
   class ImageLayer;
   class ElevationLayer;
   //class FeatureModelLayer; // FIXME: Can put back once FeatureModelLayerVector is defined in makOsgEarth
   //class AerodromeLayer; // FIXME: Can put back once AerodromeLayerVector is defined in makOsgEarth
   class ModelLayer;
   class LandCoverLayer;
   class MaskLayer;
   namespace Splat
   {
      class BiomeZone;
      class GroundCoverLayer;
      class RoadSurfaceLayer;
      class SplatLayer;
   }
   namespace Buildings
   {
      class BuildingLayer;
   }
}

namespace makArchives
{
   class DtModelDefinitionRecord;
}

namespace makVrv
{
   // Class Forward Declarations
   class DtTerrainEditorInterface;
   class DtTerrainPatch;
   class DtTerrainPatchObject;
   class DtFeatureLayer;
   class DtOceanLayer;
   class DtOsgEarthDataRequestQueue;
   class DtOsgEarthDataRequest;
   class DtOsgEarthFileParser;
   class DtOsgEarthFile;

   class DT_DLL_VRVTERRAINEDITOR DtTerrainEditorLogic
   {
      typedef std::vector< osg::ref_ptr<osgEarth::FeatureModelLayer> > FeatureModelLayerVector;
      typedef std::vector< osg::ref_ptr<osgEarth::FeatureSource> > FeatureSourceLayerVector;
      typedef std::vector< osg::ref_ptr<osgEarth::Aerodrome::AerodromeLayer> > AerodromeLayerVector;

   public:
      friend class DtTerrainEditorLogicCreator;
      friend class DtTerrainEditorMapCallbak;

      virtual ~DtTerrainEditorLogic();

   protected:

      class DtTerrainEditorMapCallbak : public osgEarth::MapCallback
      {
      public:
         DtTerrainEditorMapCallbak(DtTerrainEditorLogic* logic);

         virtual void onLayerAdded(osgEarth::Layer* layer, unsigned index);

         virtual void onLayerRemoved(osgEarth::Layer* layer, unsigned index);

      protected:
         DtTerrainEditorLogic* myLogic;
      };

      DtTerrainEditorLogic(DtDe& de, DtTerrainEditorInterface* iFace);

      virtual void connectSignals();

      virtual void disconnectSignals();

      virtual void syncCurrentScene();

      virtual void populateTerrainPatch(const DtTerrainPatchObject* terrainPatchObject, int sequence);

      virtual void populateFeatureLayer(const DtFeatureLayer* featureLayer, int sequence);

      virtual void populateOceanLayer(const DtOceanLayer* oceanLayer, int sequence);

      virtual int findIndexForGroupItem(const DtTerrainEditorInterface::TerrainContentItemKey& key);

      virtual DtUnicode findFileNameOfTerrainPatch(const std::string& terrainDefinition);

      virtual bool isOsgEarthTerrain(const DtUnicode& fileName);

      virtual std::string getTerrainContentGroupItemDisplayName(int type);

      virtual void processOsgEarthTerrain(const std::string& terrainDefinition, const DtUnicode& fileName);

      //Functions to populate the contents of an osgEarth terrain.

      virtual void populateOsgEarthTerrain();

      virtual void populateOsgEarthFragments();

      virtual void populateAerodromeLayers();

      virtual void populateFeatureSourceLayers();

      virtual void populateFeatureModelLayers();

      virtual void populateImageLayers();

      virtual void populateElevationLayers();

      virtual void populateModelLayers();

      virtual void populateMaskLayers();

      virtual void populateBuildingLayers();

      virtual void populateLandCoverLayers();

      virtual void populateGroundCoverLayers();

      virtual void populateGroundCovers(osgEarth::Splat::GroundCoverLayer* groundCoverLayer);

      virtual void populateRoadSurfaceLayers();

      virtual void populateSplatLayers();

      virtual void populateImageLayer(osgEarth::ImageLayer* imageLayer, int sequence);

      virtual void populateAerodromeLayer(osgEarth::Aerodrome::AerodromeLayer* aerodromeLayer, int sequence);

      virtual void populateFeatureSourceLayer(osgEarth::FeatureSource* featureSourceLayer, int sequence);

      virtual void populateFeatureModelLayer(osgEarth::FeatureModelLayer* featureModelLayer, int sequence);

      virtual void populateElevationLayer(osgEarth::ElevationLayer* elevationLayer, int sequence);

      virtual void populateModelLayer(osgEarth::ModelLayer* modelLayer, int sequence);

      virtual void populateMaskLayer(osgEarth::MaskLayer* maskLayer, int sequence);

      virtual void populateBuildingLayer(osgEarth::Buildings::BuildingLayer* buildingLayer, int sequence);

      virtual void populateLandCoverLayer(osgEarth::LandCoverLayer* layer, int sequence);

      virtual void populateGroundCoverLayer(osgEarth::Splat::GroundCoverLayer* layer, int sequence);

      virtual void populateBiomeZone(const DtTerrainEditorInterface::TerrainContentItemKey& parentkey, const osgEarth::Splat::BiomeZone& zone, int sequence);

      virtual void populateRoadSurfaceLayer(osgEarth::Splat::RoadSurfaceLayer* layer, int sequence);

      virtual void populateSplatLayer(osgEarth::Splat::SplatLayer* layer, int sequence);


      virtual void onImageLayerCreated(osgEarth::ImageLayer* imageLayer);

      virtual void onElevationLayerCreated(osgEarth::ElevationLayer* elevationLayer);

      virtual void onModelLayerCreated(osgEarth::ModelLayer* modelLayer);

      virtual void onMaskLayerCreated(osgEarth::MaskLayer* maskLayer);

      virtual void syncImageLayerToOsgEarthFile(osgEarth::ImageLayer* imageLayer);

      virtual void syncElevationLayerToOsgEarthFile(osgEarth::ElevationLayer* elevationLayer);

      virtual void syncModelLayerToOsgEarthFile(osgEarth::ModelLayer* modelLayer);

      virtual void syncMaskLayerToOsgEarthFile(osgEarth::MaskLayer* maskLayer);

      virtual void syncMaskConfigToOsgEarthFile(const std::string& name, const std::string& boundary);

      virtual void removeConfigInOsgEarthFile(const std::string& key, const std::string& name);

      virtual void onOsgEarthTerrainCleared();

      // slots connected to DtTerrainPatchObjectSignaler signals

      virtual void slot_terrainPatchCreated(DtTerrainPatchObject& terrainPatchObject);
      virtual void slot_terrainPatchToBeDeleted(const DtTerrainPatch& patch);

      // slots connected to DtTerrainSignaler signals

      virtual void slot_featureLayerAdded(const DtFeatureLayer& layer);
      virtual void slot_featureLayerToBeDeleted(const DtFeatureLayer& layer);
      virtual void slot_oceanLayerAdded(const DtOceanLayer& layer);
      virtual void slot_oceanLayerToBeDeleted(const DtOceanLayer& layer);
      virtual void slot_terrainCleared();


      //| Methods connected to DtTerrainEditorInterface signals

      virtual void slot_terrainContentTreeWidget_itemRenamed(const DtTerrainEditorInterface::TerrainContentItemKey& key,
         const std::string& oldName, const std::string& newName);

      virtual void slot_terrainContentTreeWidget_itemDoubleClicked(const DtTerrainEditorInterface::TerrainContentItemKey& key);

      virtual void slot_terrainContentTreeWidget_itemVisibilityChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, bool visible);

      virtual void slot_osgEarthFragmentTreeWidget_currentItemChanged(const std::string& key);

      virtual void slot_terrainContentCommitChangesButtonReleased(const DtTerrainEditorInterface::TerrainContentItemKey& key);

      virtual void slot_terrainContentRevertChangesButtonReleased(const DtTerrainEditorInterface::TerrainContentItemKey& key);

      virtual void slot_terrainPropertyTreeWidgetItem_currentItemChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key);

      virtual void slot_osgEarthFragmentCommitChangesButtonReleased(const std::vector<DtTerrainEditorInterface::TerrainContentItemKey>& keys);

      virtual void slot_terrainRuntimeTreeWidgetItem_currentItemChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key);

      virtual void slot_moveTerrainContentTreeWidgetItem(const DtTerrainEditorInterface::TerrainContentItemKey& key, bool up);

      virtual void slot_saveTerrainContentTreeWidgetItem(const DtTerrainEditorInterface::TerrainContentItemKey& key);

      virtual void slot_deleteTerrainContentTreeWidgetItem(const DtTerrainEditorInterface::TerrainContentItemKey& key);

      virtual void slot_addTerrainPatchButtonReleased(const DtUnicode& fileName);

      virtual void slot_addFeatureLayerButtonReleased(const DtUnicode& fileName);

      virtual void slot_addOceanLayerButtonReleased();

      virtual void slot_generateBoundaryButton_released();
      
      virtual void slot_osgEarthTerrainLayerRequestAdded(int type, const std::string& name, const std::string& driver, const DtUnicode& url);

      virtual void slot_osgEarthModelLayerRequestAdded(const std::string& name, const std::string& driver, const DtUnicode& url, const std::string& wfsType);

      virtual void slot_generateBoundary(const std::string& terrainPatchDefinition, const std::string& name, bool geocentric, bool convexHull);

      virtual void slot_generateCacheButtonReleased();
 
      virtual void slot_saveTerrain();

      virtual void slot_quit();

      virtual void slot_addData(std::vector<std::string> files);

      //| Methods connected to runtime options widget signals

      virtual void slot_visibleLayerVisiblityChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, bool visible);

      virtual void slot_visibleLayerOpacityChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, double opacity);

      virtual void slot_visibleLayerMinVisibleRangeChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, double minRange);

      virtual void slot_visibleLayerMaxVisibleRangeChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, double maxRange);

      virtual void slot_modelLayerLightingChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, bool lighting);

      virtual void slot_oceanLayerHeightChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, double height);

      virtual void slot_oceanLayerLodChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, int lod);

      virtual void slot_groundCoverWindChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, double wind);

      virtual void slot_groundCoverFillChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, double fill);

      virtual void slot_groundCoverMaxDistanceChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, double maxDistance);

      //| Methods used to navigate the camera to the center of the interested terrain content.

      virtual void moveCameraToGeoExtent(const osgEarth::GeoExtent& geoExtent);

      virtual void moveCameraToTerrainCenter(const std::string& terrainDefinition);

      osgEarth::GeoExtent findGeoExtentForGroundCoverLayer(osgEarth::Splat::GroundCoverLayer* layer);

      //osgEarth::GeoExtent findGeoExtentForGroundCover(osgEarth::Splat::GroundCover* cover, int groundCoverLayerId);

      osgEarth::GeoExtent findGeoExtentForSplatLayer(osgEarth::Splat::SplatLayer* layer);


      //| Methods used to update the earth file with the given config.
      //| Methods used to update mtf file with the terrain patch record.

      virtual void updateOsgEarthTerrainProperty(const std::string& oldName, const osgEarth::MapOptions& mapOptions,
         const osgEarth::MapNodeOptions& mapNodeOptions, const osgEarth::TerrainOptions& terrainOptions);

      virtual void updateImageLayerProperty(osgEarth::ImageLayer* layer, const osgEarth::ImageLayerOptions& options);

      virtual void updateElevationLayerProperty(osgEarth::ElevationLayer* layer, const osgEarth::ElevationLayerOptions& options);

      virtual void updateModelLayerProperty(osgEarth::ModelLayer* layer, const osgEarth::ModelLayerOptions& options);

      virtual void updateOpenFlightTerrainProperty(DtTerrainPatch* patch, const makArchives::DtModelDefinitionRecord& rec);

      virtual void updateFeatureLayerProperty(DtFeatureLayer* layer, const makArchives::DtFeatureLayerRecord& rec);

      virtual void updateOceanLayerProperty(DtOceanLayer* layer, const makArchives::DtOceanLayerRecord& rec);


      //| Methods used to get the osgEarth::Config from the config option, can not just call ConfigOptions::getConfig() since it's easy
      //| to miss/dulplicate config.

      virtual void getConfigForOsgEarthTerrainProperty(const osgEarth::MapOptions& mapOptions, const osgEarth::MapNodeOptions& mapNodeOptions,
         const osgEarth::TerrainOptions& terrainOptions, osgEarth::Config& mapConfig, osgEarth::Config& optionConfig);

      virtual void getConfigForImageLayer(osgEarth::ImageLayer* layer, const osgEarth::ImageLayerOptions& options, osgEarth::Config& optionConfig);

      virtual void getConfigForElevationLayer(osgEarth::ElevationLayer* layer, const osgEarth::ElevationLayerOptions& options, osgEarth::Config& optionConfig);

      virtual void getConfigForModelLayer(osgEarth::ModelLayer* layer, const osgEarth::ModelLayerOptions& options, osgEarth::Config& optionConfig);

      virtual void getConfigForMaskLayer(osgEarth::MaskLayer* layer, const osgEarth::MaskLayerOptions& options, osgEarth::Config& optionConfig);


      virtual void setTerrainPropertyItemOption(const DtTerrainEditorInterface::TerrainContentItemKey& key);

      virtual void setTerrainRuntimeItemOption(const DtTerrainEditorInterface::TerrainContentItemKey& key);

      virtual void setOsgEarthFragmentOptions(const DtOsgEarthFile* file);

      virtual void commitChange(const DtTerrainEditorInterface::TerrainContentItemKey& key);

      DtOsgEarthDataRequest* createOsgEarthTerrainLayerRequest(int type, const std::string& name, const std::string& driver, const DtUnicode& url);

      DtOsgEarthDataRequest* createOsgEarthModelLayerRequest(const std::string& name, const std::string& driver, const DtUnicode& url, const std::string& wfsType);

      virtual void reloadTerrainPatch(const std::string& terrainDefinition);
      
      virtual void reloadOsgEarthTerrain();

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

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

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

      virtual bool ifTerrainContentItemHasProperty(DtTerrainEditorInterface::TerrainContentItemType type);
      
      virtual void removeTemplateFiles();

      virtual void addData(const std::string& url);

      //| Methods used to save the terrain content item(if appliable).

      virtual void saveTerrain();

      virtual void saveTerrainPatches();

      virtual void saveFeatureLayers();

      virtual void saveOceanLayers();

      virtual void saveImageLayers();

      virtual void saveElevationLayers();

      virtual void saveModelLayers();

      virtual void saveBuildingLayers();

      virtual void saveLandCoverLayers();

      virtual void saveGroundCoverLayers();

      virtual void saveRoadSurfaceLayers();

      virtual void saveSplatLayers();

      virtual void saveOsgEarthTerrain();

      virtual void saveTerrainPatch(DtTerrainPatch* patch);

      virtual void saveFeatureLayer(DtFeatureLayer* feature);

      virtual void saveOceanLayer(DtOceanLayer* ocean);

      virtual void saveImageLayer(osgEarth::ImageLayer* layer);

      virtual void saveElevationLayer(osgEarth::ElevationLayer* layer);

      virtual void saveModelLayer(osgEarth::ModelLayer* layer);

      virtual void saveBuildingLayer(osgEarth::Buildings::BuildingLayer* layer);

      virtual void saveLandCoverLayer(osgEarth::LandCoverLayer* layer);

      virtual void saveGroundCoverLayer(osgEarth::Splat::GroundCoverLayer* layer);

      virtual void saveRoadSurfaceLayer(osgEarth::Splat::RoadSurfaceLayer* layer);

      virtual void saveSplatLayer(osgEarth::Splat::SplatLayer* layer);

      virtual void saveOsgEarthLayer(osgEarth::Layer* layer);


      //| Methods used to remove the terrain content item.
      
      virtual void removeTerrain();

      virtual void removeTerrainPatches();

      virtual void removeFeatureLayers();

      virtual void removeOceanLayers();

      virtual void removeImageLayers();

      virtual void removeElevationLayers();

      virtual void removeModelLayers();

      virtual void removeBuildingLayers();

      virtual void removeLandCoverLayers();

      virtual void removeGroundCoverLayers();

      virtual void removeRoadSurfaceLayers();

      virtual void removeSplatLayers();

      virtual void removeOsgEarthTerrain();

      virtual void removeTerrainPatch(DtTerrainPatch* patch);

      virtual void removeFeatureLayer(DtFeatureLayer* feature);

      virtual void removeOceanLayer(DtOceanLayer* ocean);

      virtual void removeImageLayer(osgEarth::ImageLayer* layer);

      virtual void removeElevationLayer(osgEarth::ElevationLayer* layer);

      virtual void removeModelLayer(osgEarth::ModelLayer* layer);

      virtual void removeBuildingLayer(osgEarth::Buildings::BuildingLayer* layer);

      virtual void removeLandCoverLayer(osgEarth::LandCoverLayer* layer);

      virtual void removeGroundCoverLayer(osgEarth::Splat::GroundCoverLayer* layer);

      virtual void removeRoadSurfaceLayer(osgEarth::Splat::RoadSurfaceLayer* layer);

      virtual void removeSplatLayer(osgEarth::Splat::SplatLayer* layer);

      virtual void removeOsgEarthLayer(osgEarth::Layer* layer);

      //| Methods used to change the runtime property(visibility, visible range, etc) of the terrain content item.
      
      virtual void setTerrainVisibility(bool visible);

      virtual void setTerrainPatchesVisibility(bool visible);

      virtual void setFeatureLayersVisibility(bool visible);

      virtual void setOceanLayersVisibility(bool visible);

      virtual void setImageLayersVisibility(bool visible);

      virtual void setElevationLayersVisibility(bool visible);

      virtual void setModelLayersVisibility(bool visible);

      virtual void setBuildingLayersVisibility(bool visible);

      virtual void setLandCoverLayersVisibility(bool visible);

      virtual void setGroundCoverLayersVisibility(bool visible);

      virtual void setRoadSurfaceLayersVisibility(bool visible);

      virtual void setSplatLayersVisibility(bool visible);

      virtual void setOsgEarthTerrainVisibility(bool visible);

      virtual void setTerrainPatchVisibility(DtTerrainPatch* patch, bool visible);

      virtual void setFeatureLayerVisibility(DtFeatureLayer* feature, bool visible);

      virtual void setOceanLayerVisibility(DtOceanLayer* ocean, bool visible);

      virtual void setVisibleLayerVisibility(osgEarth::VisibleLayer* layer, bool visible);
      
      virtual void setVisibleLayerOpacity(osgEarth::VisibleLayer* layer, double opacity);

      virtual void setVisibleLayerMinVisibleRange(osgEarth::VisibleLayer* layer, double minRange);

      virtual void setVisibleLayerMaxVisibleRange(osgEarth::VisibleLayer* layer, double maxRange);

      virtual void setModelLayerLighting(osgEarth::ModelLayer* layer, bool lighting);

      //virtual void setGroundCoverWind(osgEarth::Splat::GroundCover* cover, double wind);

      //virtual void setGroundCoverFill(osgEarth::Splat::GroundCover* cover, double fill);

      //virtual void setGroundCoverMaxDistance(osgEarth::Splat::GroundCover* layer, double maxDistance);


      virtual void createOsgEarthTerrain();

      virtual void saveOsgEarthTerrain(const DtUnicode& fileName);

      virtual DtUnicode generateOsgEarthTerrainFileName();

      virtual DtTerrainEditorInterface::TerrainContentItemKey getTerrainContentItemKey(const std::string& type, const std::string& name);

      virtual void removeImageLayerFromFile(osgEarth::ImageLayer* layer);

      virtual void removeElevationLayerFromFile(osgEarth::ElevationLayer* layer);

      virtual void removeModelLayerFromFile(osgEarth::ModelLayer* layer);

      virtual void removeMaskLayerFromFile(osgEarth::MaskLayer* layer);

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

   protected:
      DtDe& myDe;
      std::string myOsgEarthTerrainDefinition;
      DtUnicode myOsgEarthTerrainFileName;
      std::string myOsgEarthTerrainName;
      std::string myOsgEarthTerrainDir;
      std::string myTemplatePath;
      std::set<DtUnicode> myTemplateFiles;
      DtTerrainEditorInterface::TerrainContentItemKey myOsgEarthTerrainKey;
      std::string myMedfTerrainDir;
      osg::observer_ptr<osgEarth::MapNode> myMapNode;
      osg::observer_ptr<osgEarth::Map> myMap;

      DtTerrainEditorInterface* myInterface;
      DtSignalConnectionManager mySignals;
      DtOsgEarthDataRequestQueue* myOsgEarthDataRequestQueue;
      DtOsgEarthFileParser* myOsgEarthFileParser;
      bool myNeedSaveEarthFile;
      bool myReloadFlag;
      std::string myReloadModelName;
      int myInsertIndex;
      std::set<std::string> myImageLayerExtensions;
      std::set<std::string> myElevationLayerExtensions;

      static bool myDontShowReloadTerrainWarningMessageBox;

   };

   class DT_DLL_VRVTERRAINEDITOR DtTerrainEditorLogicCreator
      : public DtVirtualBaseClass
   {
   public:

      // Get the creator instance for this DE object.  Creates instance if none found
      static DtTerrainEditorLogicCreator& instance(DtDe& de);

      static void registerInstance(DtDe& de, DtTerrainEditorLogicCreator* creator);

      //Create the widget's logic.
      static DtTerrainEditorLogic* create(DtDe& de, DtTerrainEditorInterface* iface);
   };
}