DtTerrainEditorLogic.h

Go to the documentation of this file.

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


#pragma once

#include <vrvTerrainEditor/vrvTerrainEditor.h>
#include <vrvTerrainEditor/DtTerrainEditorInterface.h> 

#include <osgEarth/MapCallback>
#include <osgEarth/GeoData>

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

#include <osg/observer_ptr>

#include <makArchives/DtTerrainRecord.h>

// Class Forward Declarations
namespace osgEarth
{
   class MapNode;
   class Layer;
   class ImageLayer;
   class ElevationLayer;
   class FeatureModelLayer;
   class ModelLayer;
   class LandCoverLayer;
   class TerrainConstraintLayer;
   namespace Splat
   {
      class GroundCoverLayer;
      class RoadSurfaceLayer;
      class SplatLayer;
   }
   namespace Buildings
   {
      class BuildingLayer;
   }
}

namespace makArchives
{
   class DtModelDefinitionRecord;
}

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

   class DT_DLL_VRVTERRAINEDITOR DtTerrainEditorLogic
   {
   public:
      friend class DtTerrainEditorLogicCreator;
      friend class DtTerrainEditorMapCallbak;

      virtual ~DtTerrainEditorLogic();

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

   public:

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

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

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

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


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

      //Various Helper Functions

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

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

      virtual bool isOsgEarthTerrain(const DtUnicode& fileName);

      int getContentGroupKeyTypeFromClassName(const std::string& className) const;

      int getContentItemKeyTypeFromClassName(const std::string& className) const;

      virtual std::string getTerrainContentGroupItemDisplayName(int type);

      bool isTerrainContentItemVisibilityCheckboxEnabled(int type) const;


      //Functions to populate the terrain content tree with VRV-specific terrain contents

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

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

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


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

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

      template <typename T>
      void populateOsgEarthLayers();

      virtual void populateOsgEarthLayer(osg::ref_ptr < osgEarth::Layer > layer, int index);

      virtual void populateOsgEarthTerrain();

      virtual void populateOsgEarthFragments();

      virtual void populateImageLayers();

      virtual void populateElevationLayers();

      virtual void populateLandCoverLayers();

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

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

      virtual void populateLandCoverLayer(osgEarth::LandCoverLayer* 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::TerrainConstraintLayer* maskLayer);

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

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

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

      virtual void syncMaskLayerToOsgEarthFile(osgEarth::TerrainConstraintLayer* 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_terrainLoaded(const makArchives::DtTerrainRecord&);
      virtual void slot_terrainToBeCleared(bool reload);
      virtual void slot_clientAdded();
      virtual void slot_terrainCleared();


      //| Methods connected to DtTerrainEditorInterface signals

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

      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_saveTerrainContentTreeWidgetItem(const DtTerrainEditorInterface::TerrainContentItemKey& key);

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

      virtual void slot_addFeatureLayerButtonReleased(const DtUnicode& fileName, bool toFrontEnd, bool toSimEngine);

      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, Qt::KeyboardModifiers keyModifiers);

      //| Methods connected to runtime options widget signals
      
      virtual void slot_terrainDescriptionChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, const std::string& description);
      
      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_osgEarthDebugModeStateChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, bool enabled);

      virtual void slot_terrainMaxPagedLODsChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, int maxPagedLODs);

      virtual void slot_terrainPatchIsPageableStateChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, bool enabled);

      virtual void slot_terrainPatchPageOutDistanceChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, double pageOutDistance);

      virtual void slot_oceanLayerNameChanged(const DtTerrainEditorInterface::TerrainContentItemKey& key, const std::string& name);

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

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


      //| 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::TerrainConstraintLayer* layer, const osgEarth::MaskLayerOptions& options, osgEarth::Config& optionConfig);


      virtual void setTerrainPropertyItemOption(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, QFlags<Qt::KeyboardModifier> keyModifiers);

      //| 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 removeOsgEarthFeatureLayers();

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

      template <typename T>
      void setOsgEarthLayerVisibility(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 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::TerrainConstraintLayer* layer);

   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;
      DtSignalConnectionManager myWhileTerrainIsLoadedSignals;
      DtOsgEarthDataRequestQueue* myOsgEarthDataRequestQueue;
      DtOsgEarthFileParser* myOsgEarthFileParser;
      bool myNeedSaveEarthFile;
      bool myReloadFlag;
      std::string myReloadModelName;
      int myInsertIndex;

      makArchives::DtTerrainRecord myOriginalTerrainRecord;

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