DtTerrainEditorInterface.h

Go to the documentation of this file.

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

#pragma once

#include <vrvTerrainEditor/vrvTerrainEditor.h>
#include <vrvUtil/DtUnicode.h>

namespace osgEarth
{
   class MapOptions;
   class MapNodeOptions;
   class TerrainOptions;
   class ImageLayerOptions;
   class ElevationLayerOptions;
   class ModelLayerOptions;
   class MaskLayerOptions;
   class LandCoverLayerOptions;
   namespace Buildings
   {
      class BuildingLayerOptions;
   }
   namespace Splat
   {
      class GroundCoverLayerOptions;
      class GroundCoverOptions;
      class RoadSurfaceLayerOptions;
      class SplatLayerOptions;
   }
}

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

namespace makVrv
{
   class DtOsgEarthXmlReference;
   class DtOsgEarthFileParser;

   class DT_DLL_VRVTERRAINEDITOR DtTerrainEditorInterface
   {
   public:

      //Type of the terrain content item.
      enum TerrainContentItemType
      {
         Terrain,
         ImageLayerGroup,
         ElevationLayerGroup,
         ModelLayerGroup,
         MaskLayerGroup,
         BuildingLayerGroup,
         LandCoverLayerGroup,
         GroundCoverLayerGroup,
         RoadSurfaceLayerGroup,
         SplatLayerGroup,
         TerrainPatchGroup,
         OceanLayerGroup,
         FeatureSourceGroup,
         FeatureLayerGroup,
         OsgEarthTerrainPatch,
         OpenFlightTerrainPatch,
         FeatureSource,
         FeatureLayer,
         OceanLayer,
         ImageLayer,
         ElevationLayer,
         ModelLayer,
         MaskLayer,
         BuildingLayer,
         LandCoverLayer,
         GroundCoverLayer,
         GroundCover,
         RoadSurfaceLayer,
         SplatLayer,
         TreeWidget,
         CompositeParentLayer,
         CompositeChildLayer,
         UnknownType
      };

      class TerrainContentItemKey
      {
      public:

         TerrainContentItemKey();

         TerrainContentItemKey(int type, int id, const TerrainContentItemKey& parentKey);

         TerrainContentItemKey(int type, const std::string& name, const TerrainContentItemKey& parentKey);

         TerrainContentItemKey(int type, const std::string& name, int parentType, int parentId);

         TerrainContentItemKey(int type, int id, int parentType, int parentId);

         void invalid();

         void setType(int type);

         void setId(int id);

         void setParentType(int type);

         void setParentId(int id);

         void setParentKey(const TerrainContentItemKey& parentKey);

         void setName(const std::string& name);

         const int type() const;

         const int id() const;

         const int parentType() const;

         const int parentId() const;
         
         std::string name() const;

         const bool useName() const;

         bool operator<(const TerrainContentItemKey&) const;

         bool operator==(const TerrainContentItemKey&) const;

      protected:
         int myType;
         int myId;
         int myParentType;
         int myParentId;
         bool myUseName;
         std::string myName;
      };

      virtual void addTerrainContentTopLevelItem(const TerrainContentItemKey& key, const std::string& displayName) = 0;

      virtual void addTerrainContentItem(const TerrainContentItemKey& key, const TerrainContentItemKey& parentKey, const std::string& displayName,
          int index=-1, bool editable = false, bool checked = true ) = 0;

      virtual void addOsgEarthFragmentContentTopLevelItem(const std::string& key, const std::string& displayName) = 0;

      virtual void addOsgEarthFragmentContentItem(const std::string& key, const std::string& parentKey, const std::string& displayName) = 0;

      virtual void clearTreeWidgets() = 0;

      virtual void setFocusOnTerrainContentTreeWidgetItem(const TerrainContentItemKey& key, bool expanded = true) = 0;

      virtual void removeTerrainContentTreeWidgetItem(const TerrainContentItemKey& key) = 0;

      virtual bool hasTerrainContentTreeWidgetItem(const TerrainContentItemKey& key) = 0;

      virtual bool hasTerrainPropertyTreeWidgetItem(const TerrainContentItemKey& key) = 0;

      virtual void cleanOsgEarthFragmentTreeWidget() = 0;

      virtual void setSelectedOsgEarthFragmentKeys(const std::vector<TerrainContentItemKey>& keys) = 0;

      virtual void moveTerrainContentTreeWidgetItem( TerrainContentItemKey key, bool up) = 0;

      virtual void setGenerateCacheButtonEnabled(bool enabled) = 0;

      virtual void setGenerateBoundaryButtonEnabled(bool enabled) = 0;

      virtual void setSaveTerrainButtonEnabled(bool enabled) = 0;

      virtual void setCommitChangeButtonEnabled(bool enabled) = 0;
      
      virtual void setRevertChangeButtonEnabled(bool enabled) = 0;

      virtual void enableOsgEarthFragmentTabWidget(bool enabled) = 0;

      virtual void enableTerrainRuntimeTabWidget(bool enabled) = 0;

      virtual void resizeTerrainPropertyTreeWidget() = 0;

      virtual void resizeTerrainRuntimeTreeWidget() = 0;

      virtual void resizeTerrainFragmentTreeWidget() = 0;

      virtual void setTerrainPropertyTreeItemName(const std::string& name) = 0;

      virtual void setTerrainPropertyTreeItemVisiblity(bool visible) = 0;

      virtual void showTerrainPropertyTreeWidgetItem(const TerrainContentItemKey& key) = 0;

      virtual void showTerrainPropertyTreeWidgetItems(const std::vector<TerrainContentItemKey>& keys) = 0;

      virtual void showTerrainRuntimeTreeWidgetItem(const TerrainContentItemKey& key) = 0;

      //| Methods used to set/get the property in the terrain property tree widget

      virtual void setOsgEarthTerrainProperty(const TerrainContentItemKey& key, const osgEarth::MapOptions& mapOptions,
         const osgEarth::MapNodeOptions& mapNodeOptions, const osgEarth::TerrainOptions& terrainOptions) = 0;

      virtual void getOsgEarthTerrainProperty(const TerrainContentItemKey& key, osgEarth::MapOptions& mapOptions,
         osgEarth::MapNodeOptions& mapNodeOptions, osgEarth::TerrainOptions& terrainOptions) = 0;

      virtual void setTerrainPatchProperty(const TerrainContentItemKey& key, const makArchives::DtModelDefinitionRecord& rec) = 0;

      virtual void getTerrainPatchProperty(const TerrainContentItemKey& key, makArchives::DtModelDefinitionRecord& rec) = 0;

      virtual void setFeatureLayerProperty(const TerrainContentItemKey& key, const makArchives::DtFeatureLayerRecord& rec) = 0;

      virtual void getFeatureLayerProperty(const TerrainContentItemKey& key, makArchives::DtFeatureLayerRecord& rec) = 0;

      virtual void setOceanLayerProperty(const TerrainContentItemKey& key, const makArchives::DtOceanLayerRecord& rec) = 0;

      virtual void getOceanLayerProperty(const TerrainContentItemKey& key, makArchives::DtOceanLayerRecord& rec) = 0;

      virtual void setImageLayerProperty(const TerrainContentItemKey& key, const osgEarth::ImageLayerOptions& option) = 0;

      virtual void getImageLayerProperty(const TerrainContentItemKey& key, osgEarth::ImageLayerOptions& option) = 0;

      virtual void setElevationLayerProperty(const TerrainContentItemKey& key, const osgEarth::ElevationLayerOptions& option) = 0;

      virtual void getElevationLayerProperty(const TerrainContentItemKey& key, osgEarth::ElevationLayerOptions& option) = 0;

      virtual void setModelLayerProperty(const TerrainContentItemKey& key, const osgEarth::ModelLayerOptions& option) = 0;

      virtual void getModelLayerProperty(const TerrainContentItemKey& key, osgEarth::ModelLayerOptions& option) = 0;

      virtual void setMaskLayerProperty(const TerrainContentItemKey& key, const osgEarth::MaskLayerOptions& option) = 0;

      virtual void setBuildingLayerProperty(const TerrainContentItemKey& key, const osgEarth::Buildings::BuildingLayerOptions& option) = 0;

      virtual void setLandCoverLayerProperty(const TerrainContentItemKey& key, const osgEarth::LandCoverLayerOptions& option) = 0;

      virtual void setGroundCoverLayerProperty(const TerrainContentItemKey& key, const osgEarth::Splat::GroundCoverLayerOptions& option) = 0;

      virtual void setGroundCoverProperty(const TerrainContentItemKey& key, const osgEarth::Splat::GroundCoverOptions& option) = 0;

      virtual void setRoadSurfaceLayerProperty(const TerrainContentItemKey& key, const osgEarth::Splat::RoadSurfaceLayerOptions& option) = 0;

      virtual void setSplatLayerProperty(const TerrainContentItemKey& key, const osgEarth::Splat::SplatLayerOptions& option) = 0;


      virtual void showCacheDialog(const std::string& osgEarthTerrainDefinition) = 0;

      virtual DtUnicode showSaveMtfFileDialog(const DtUnicode& directory) = 0;

      virtual DtUnicode showSaveOsgEarthFileDialog(const DtUnicode& directory) = 0;

      virtual void showSaveFileConfirmationMessageBox(const DtUnicode& fileName) = 0;

      virtual bool showOverrideOsgEarthFileDialog() = 0;

      virtual bool showWarnReloadTerrainMessageBox(bool& checked) = 0;

      virtual bool showReloadTerrainAfterGenerateMaskMessageBox(const std::string& terrainPatch) = 0;

      virtual bool showChooseLayerTypeMessageBox(const DtUnicode& url, int& type) = 0;

      virtual void showFileExtensionNotSupportedMessageBox(const DtUnicode& fileName) = 0;

      virtual void setGenerateBoundaryModels(const std::vector<std::string>& models) = 0;
      
      //| Methods used to set the runtime property of the terrain content item(Does not require commiting changes).

      virtual void setOceanLayerHeight(const TerrainContentItemKey& key, double height) = 0;

      virtual void setOceanLayerLod(const TerrainContentItemKey& key, int lod) = 0;

      virtual void setLayerVisiblity(const TerrainContentItemKey& key, bool visible) = 0;

      virtual void setLayerOpacity(const TerrainContentItemKey& key, double opacity) = 0;

      virtual void setLayerMinVisibleRange(const TerrainContentItemKey& key, double range) = 0;

      virtual void setLayerMaxVisibleRange(const TerrainContentItemKey& key, double range) = 0;

      virtual void setGroundCoverWind(const TerrainContentItemKey& key, double wind) = 0;

      virtual void setGroundCoverFill(const TerrainContentItemKey& key, double fill) = 0;

      virtual void setGroundCoverMaxDistance(const TerrainContentItemKey& key, double maxDistance) = 0;


      virtual void expandTerrainContentTreeWidget() = 0;

      virtual void expandOsgEarthFragmentTreeWidget() = 0;

      virtual int getIndexOfTerrainContentItem(const TerrainContentItemKey& key) = 0;

   public:


      boost::signal<void(const TerrainContentItemKey& key)> signal_terrainPropertyTreeWidgetItem_currentItemChanged;

      boost::signal<void(const TerrainContentItemKey& key)> signal_terrainRuntimeTreeWidgetItem_currentItemChanged;
   
      boost::signal<void(const TerrainContentItemKey& key)> signal_terrainContentTreeWidget_itemDoubleClicked; 

      boost::signal<void(const TerrainContentItemKey& key, bool visible)> signal_terrainContentTreeWidget_itemVisibilityChanged;

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

      boost::signal<void(const TerrainContentItemKey& key)> signal_terrainContentCommitChangesButtonReleased;

      boost::signal<void(const TerrainContentItemKey& key)> signal_terrainContentRevertChangesButtonReleased;

      boost::signal<void(const std::vector<TerrainContentItemKey>& keys)> signal_osgEarthFragmentCommitChangesButtonReleased;

      boost::signal<void(const TerrainContentItemKey& key, const std::string& oldName, const std::string& newName)> signal_renameTerrainContentTreeWidgetItem;

      boost::signal<void(const TerrainContentItemKey& key, bool up)> signal_moveTerrainContentTreeWidgetItem;

      boost::signal<void(const TerrainContentItemKey& key)> signal_saveTerrainContentTreeWidgetItem;

      boost::signal<void(const TerrainContentItemKey& key)> signal_deleteTerrainContentTreeWidgetItem;

      boost::signal<void()> signal_generateBoundaryButton_released;

      boost::signal<void(const DtUnicode& fileName)> signal_addTerrainPatchButtonReleased;

      boost::signal<void(const DtUnicode& fileName)> signal_addFeatureLayerButtonReleased;

      boost::signal<void()> signal_addOceanLayerButtonReleased;

      boost::signal<void(int type, const std::string& name, const std::string& driver, const DtUnicode& url)> signal_osgEarthTerrainLayerRequestAdded;

      boost::signal<void(const std::string& name, const std::string& driver, const DtUnicode& url, const std::string& wfsType)> signal_osgEarthModelLayerRequestAdded;

      boost::signal<void(const std::string& definition, const std::string& name, bool geocentric, bool convexHull)> signal_generateBoundary;

      boost::signal<void()> signal_saveOsgEarthTerrain;

      boost::signal<void()> signal_saveTerrain;

      boost::signal<void(const TerrainContentItemKey& key, bool visible)> signal_visibleLayerVisiblityChanged;

      boost::signal<void(const TerrainContentItemKey& key, double opacity)> signal_visibleLayerOpacityChanged;

      boost::signal<void(const TerrainContentItemKey& key, double minRange)> signal_visibleLayerMinVisibleRangeChanged;

      boost::signal<void(const TerrainContentItemKey& key, double maxRange)> signal_visibleLayerMaxVisibleRangeChanged;

      boost::signal<void(const TerrainContentItemKey& key, bool lighting)> signal_modelLayerLightingChanged;

      boost::signal<void(const TerrainContentItemKey& key, double height)> signal_oceanLayerHeightChanged;

      boost::signal<void(const TerrainContentItemKey& key, int lod)> signal_oceanLayerLodChanged;

      boost::signal<void(const TerrainContentItemKey& key, double wind)> signal_groundCoverWindChanged;

      boost::signal<void(const TerrainContentItemKey& key, double fill)> signal_groundCoverFillChanged;

      boost::signal<void(const TerrainContentItemKey& key, double maxDistance)> signal_groundCoverMaxDistanceChanged;

      boost::signal<void(const TerrainContentItemKey& key, double brightness)> signal_groundCoverBrightnessChanged;

      boost::signal<void(const TerrainContentItemKey& key, double contrast)> signal_groundCoverContrastChanged;

      boost::signal<void()> signal_generateCacheButtonReleased;

      boost::signal<void(std::vector<std::string>)> signal_addData;

   };
}