DtEnvironment.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtEnvironmentInterface.h>
#include <vrvCore/DtRecordSettingsBackup.h>
#include <vrvCore/DtEnvironmentList.h>
#include <vrvCore/DtRotorWashInfo.h>
#include <vrvCore/DtLocalWindObjectManager.h>

#include <makArchives/DtEnvironmentRecord.h>
#include <makArchives/DtCloudCoverType.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/event_signal.h>

namespace makArchives
{
   class DtCloudLayerRecord;
   class DtEnvironmentListRecord;
}

namespace makVrv
{
   class DtDe;
   class DtAgentManagerInterface;
   class DtSkyObjectAgent;
   class DtDynamicOceanObjectAgent;
   class DtEventQueueInterface;
   class DtSharedSettingsManager;
   class DtOceanLayer;
   class DtCloudLayer;
   class DtOceanStateInterface;
   class DtWeatherEffectsObjectAgent;

   class DT_DLL_VRVCORE DtEnvironment : public DtEnvironmentInterface
   {
   public:

      DtEnvironment(DtDe& de);

      virtual ~DtEnvironment();

      virtual void init();

      virtual void getRecord(makArchives::DtEnvironmentRecord& record);

      virtual void setFromRecord(
         const makArchives::DtEnvironmentRecord& record);

      virtual makArchives::DtEnvironmentRecord environmentConditionRecord(const std::string&);

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

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

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

      virtual void renameEnvironment(
         const std::string& oldName, const std::string& newName);

      virtual void getEnvironmentNames(std::vector<std::string>& names, 
         bool includeLocalOnlyEnvironment = false);

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

      virtual std::string defaultEnvironmentName() const;

      virtual void setLightningPresent(bool lightningPresent);
      virtual bool lightningPresent() const;

      virtual void setAirTurbidity(float turbidity);
      virtual float airTurbidity() const;

      virtual void setVisibleDistance(float distance);
      virtual float visibleDistance() const;

      virtual void setWindSpeed(float windSpeed);
      virtual float windSpeed() const;

      virtual void setWindDirection(float direction);
      virtual float windDirection() const;

      virtual void setPrecipitationType(PrecipitationType type);
      virtual PrecipitationType precipitationType() const;

      virtual void setPrecipitationIntensity(float intensity);
      virtual float precipitationIntensity() const;

      virtual void updateOrAddElevationalConfiguration(
         const DtElevationalConfigurationRecord& record);

      virtual bool getElevationalConfiguration(float baseMSLAltitude,
         makArchives::DtEnvironmentRecord::DtElevationalConfigurationRecord& wRec) const;

      virtual void removeElevationalConfiguration(float baseMSLAltitude);

      virtual void moveElevationalConfiguration(
         float oldBaseMSLAltitude, float newBaseMSLAltitude);

      virtual void setWindSpeedAtMSLAltitude(float mslAltitude, float windSpeed);

      virtual float windSpeedAtMSLAltitude(float mslAltitude) const;

      virtual void setWindDirectionAtMSLAltitude(float mslAltitude, float windDirection);

      virtual float windDirectionAtMSLAltitude(float mslAltitude) const;

      virtual void setVisibilityDistanceAtMSLAltitude(float mslAltitude, float visibilityDistance);

      virtual float visibilityDistanceAtMSLAltitude(float mslAltitude) const;

      virtual void setObscurantAtMSLAltitude(float mslAltitude, VisibilityObscurant obscurant);

      virtual VisibilityObscurant obscurantAtMSLAltitude(float mslAltitude) const;

      virtual void setCloudTypeAtMSLAltitude(float mslAltitude, CloudType cloudType);

      virtual CloudType cloudTypeAtMSLAltitude(float mslAltitude) const;

      virtual void setSkyCoverageAtMSLAltitude(float mslAltitude, float skyCoverage);

      virtual float skyCoverageAtMSLAltitude(float mslAltitude) const;

      virtual void setAmbientAirTemperature(float temperature);
      virtual float ambientAirTemperature() const;

      virtual void setAmbientAirPressure(float pressure);
      virtual float ambientAirPressure() const;

      virtual void setAirPressureAltitude(float altitude);
      virtual float airPressureAltitude() const;

      virtual void setAirTemperatureAltitude(float altitude);
      virtual float airTemperatureAltitude() const;

      virtual void setAirPressureAltitudeIsSeaLevel(bool seaLevel);
      virtual bool airPressureAltitudeIsSeaLevel() const;

      virtual void setAirTemperatureAltitudeIsSeaLevel(bool seaLevel);
      virtual bool airTemperatureAltitudeIsSeaLevel() const;

      virtual void setSeaLevelWaterConcentration(float water);
      virtual float seaLevelWaterConcentration() const;

      virtual void setFogHeight(float height);
      virtual float fogHeight() const;

      virtual void setFogColor(const DtVector& color);
      virtual DtVector fogColor() const;

      virtual void setGroundFogColor(const DtVector& color) override;
      virtual DtVector groundFogColor() const override;

      virtual void setSeaState(DtDouglasSeaState::Scale state);
      virtual DtDouglasSeaState::Scale seaState() const;

      virtual void setSeaStateDirection(float dir);
      virtual float seaStateDirection() const;

      virtual void setWindDrivenSeaState(bool enabled);
      virtual bool windDrivenSeaState() const;

      virtual void setSwellState(DtDouglasSwellState::Scale state);
      virtual DtDouglasSwellState::Scale swellState() const;

      virtual void setSwellStateDirection(float dir);
      virtual float swellStateDirection() const;

      virtual void setWindFetch(float distance);
      virtual float windFetch() const;

      virtual void setSeaChoppiness(float chop);
      virtual float seaChoppiness() const;

      void setUnderwaterVisibilityEnabled(bool enabled);
      bool underwaterVisibilityEnabled() const;

      virtual void setUnderwaterVisibility(float distance);
      virtual float underwaterVisibility() const;

      virtual void setWaterSurfaceTransparency(float normalizedValue);
      virtual float waterSurfaceTransparency() const;

      virtual void setSurgeDepth(float meters);
      virtual float surgeDepth() const;

      virtual void setDepthOffset(float meters);
      virtual float depthOffset() const;

      virtual void setAmbientWaterTemperature(float temperature);
      virtual float ambientWaterTemperature() const;

      virtual void setWaterCurrentSpeed(float speed);
      virtual float waterCurrentSpeed() const;

      virtual void setWaterCurrentDirection(float direction);
      virtual float waterCurrentDirection() const;

      virtual void setTidalOffset(float meters);
      virtual float tidalOffset() const;

      virtual void setTidalDirection(bool inOut);
      virtual bool tidalDirection() const;

      virtual void setThermoclineDepth(unsigned int layer, float depth);
      virtual float thermoclineDepth(unsigned int layer) const;

      virtual void setThermoclinePermeability(unsigned int layer, float permeability);
      virtual float thermoclinePermeability(unsigned int layer) const;

      virtual void setGroundSnowAccumulation(float depth);
      virtual float groundSnowAccumulation() const;

      virtual void setRoadSnowAccumulation(float depth);
      virtual float roadSnowAccumulation() const;

      virtual void setSnowMinimumElevation(float elevation);
      virtual float snowMinimumElevation() const;
      
      virtual void setSnowElevationTransition(float elevation);
      virtual float snowElevationTransition() const;
      
      virtual void setGroundRainAccumulation(float depth);
      virtual float groundRainAccumulation() const;

      virtual DtUniqueID addLocalWind(WindType localWindType);
      virtual void removeLocalWind(DtUniqueID id) const;

      virtual void setLocalWindLocation(DtUniqueID id, DtVector loc);

      virtual void setLocalWindSpeed(DtUniqueID id, float windSpeed);

      virtual float lightLevel() const;

      void loadDefaults(bool loadOnlyFactorySettings = false);

      void restore();

      void saveAsDefaults();

      virtual void exportSettings(const std::string& filename);
      virtual void importSettings(const std::string& filename);

      const DtSettingsBackup* settingsBackup() const
      {
         return mySettingsBackup;
      }

      DtSettingsBackup* settingsBackup()
      {
         return mySettingsBackup;
      }

      virtual float seaLevel() const;
      virtual void initializeEnvironmentSettings();

   protected:

      typedef std::vector<DtCloudLayer> CloudLayersVector;

      virtual void resetClouds();

      virtual void refreshCloudLayerThicknessIfNeeded();

      virtual void clearCloudsFromSky();

      virtual void addElevationalCloudLayersToCloudCoverManagerIfNeeded();

      virtual void sendToSkyAllCloudLayers();

      virtual void initializeCloudLayerRecordByCloudType(makArchives::DtCloudLayerRecord&) const;

      virtual void sendToSkyCloudLayerAdded(DtCloudLayerId layerId);
      virtual void sendToSkyCloudLayerEnabled(DtCloudLayerId layerId, bool enabled);
      virtual void sendToSkyCloudLayerRemoved(DtCloudLayerId layerId);
      virtual void sendToSkyCloudLayerModified(DtCloudLayerId layerId);

      
      virtual void slot_listenToRemoteEnvironmentSettingsChanged(bool allowSimMessages);
      
      virtual void slot_cloudCoverCloudLayerEnabledChanged(DtCloudLayerId layerId, bool enableState);
      virtual void slot_cloudCoverCloudLayerModified(DtCloudLayerId layerId);
      virtual void slot_cloudCoverCloudLayerPositionAndOrientationChanged(DtCloudLayerId layerId, 
         const DtVector& position, float orientation);
      virtual void slot_cloudCoverCloudLayerAdded(DtCloudLayerId layerId);
      virtual void slot_cloudCoverCloudLayerToBeRemoved(DtCloudLayerId layerId);
      virtual void slot_cloudCoverToBeRemoved(const std::string& cloudCoverName);
      
      virtual void slot_coordinateSystemChanged();

      virtual void slot_oceanLayerAdded(const DtOceanLayer& layer);

      virtual void slot_oceanLayerToBeDeleted(const DtOceanLayer& layer);

      virtual void slot_oceanLayerSeaLevelChanged(const DtOceanLayer& layer, 
         double seaLevel);

      virtual void slot_oceanLayerLodRangeChanged(const DtOceanLayer& layer, 
         int range);

      virtual void slot_surgeDepthChanged(double depth);

      virtual void slot_depthOffsetChanged(double offset);

      virtual void updateEnvironment();

      virtual void initializeOcean();

      virtual void enableCurrentCloudCoverLayers();
      virtual void disableCurrentCloudCoverLayers();

      virtual void autoSave();

      virtual void sendMarineEnvironmentToOceanObject();

      virtual void sendWeatherEnvironmentToSkyObject();

   protected:
      DtDe& myDe;
      DtAgentManagerInterface& mySceneInterface;

      // makArchives::DtEnvironmentListRecord* mySettings;

      //We should refactor these classes and combine them to make a consistent way 
      // to send down environment settings to the RDE.
      DtSkyObjectAgent* mySkyObject;
      DtDynamicOceanObjectAgent* myDynamicOceanObject;
      DtWeatherEffectsObjectAgent* myWeatherEffectsObject;
      
      DtRecordSettingsBackupInterface*  mySettingsBackup;
      DtSignalConnectionManager myConnections;
      DtSignalConnectionManager myRemoteEnvironmentConnections;

      // This is an env record that reflects our current settings
      makArchives::DtEnvironmentRecord myCurrentSettings;

      // This is used to retain the name of the (old) environment configuration
      // that was in use before switching over to the 'remote environment'.
      std::string myEnvironmentRecordNameToRestore;

      // This is an env list that reflects saved settings
      DtEnvironmentList myEnvironmentList;

      // This holds the DtLocalWindObjectAgents which 
      // ultimately sends the info to osgEarth
      DtLocalWindObjectManager& myLocalWindManager;

      float mySeaLevel;

      // Until this is in an environment record
      DtVector myGroundFogColor;
   };

   class DT_DLL_VRVCORE DtEnvironmentCreator : public DtVirtualBaseClass
   {
   public:

      static DtEnvironmentCreator& instance(DtDe& de);

      DtEnvironmentCreator();

      virtual ~DtEnvironmentCreator();

      DtEnvironment* create(DtDe& de);

   };
   class DT_DLL_VRVCORE DtEnvironmentSignaler : public DtVirtualBaseClass
   {
   public:

      static DtEnvironmentSignaler& instance(DtDe& de);

      virtual ~DtEnvironmentSignaler();

      //Signaled when any of the atmospheric parameters change.
      boost::signalslib::signal<void ()> signal_atmosphericParametersChanged;
      
      //Signaled when any of the precipitation parameters change.
      boost::signalslib::signal<void ()> signal_precipitationSettingsChanged;
      
      //Signaled when the lightning is present state has changed
      boost::signalslib::signal<void(bool)> signal_lightningPresentChanged;

      boost::signalslib::signal<void (unsigned int layerId, 
         const DtCloudLayer& newLayer)> signal_cloudLayerAdded;

      boost::signalslib::signal<void (unsigned int layerId)> signal_cloudLayerToBeDestroyed;

      boost::signalslib::signal<void (unsigned int layerId, const DtCloudLayer& changedLayer)> 
         signal_cloudLayerChanged;

      boost::signalslib::signal<void (float height)> signal_fogHeightChanged;

      boost::signalslib::signal<void (const DtVector& color)> signal_fogColorChanged;

      //Signaled when elevational configurations change.
      boost::signalslib::signal<void(float baseMSLAltitude)> signal_elevationalConfigurationRemoved;
      boost::signalslib::signal<void(float oldBaseMSLAltitude, float newBaseMSLAltitude)> signal_elevationalConfigurationMoved;
      boost::signalslib::signal<void(DtEnvironmentInterface::DtElevationalConfigurationRecord)> signal_elevationalConfigurationAdded;
      boost::signalslib::signal<void(DtEnvironmentInterface::DtElevationalConfigurationRecord)> signal_elevationalConfigurationUpdated;

      //Signaled when air parameters change.
      boost::signalslib::signal<void (float kelvins)> signal_ambientAirTemperatureChanged;
      boost::signalslib::signal<void (float pressure)> signal_ambientAirPressureChanged;
      boost::signalslib::signal<void (float altitude)> signal_airTemperatureAltitudeChanged;
      boost::signalslib::signal<void (float altitude)> signal_airPressureAltitudeChanged;
      boost::signalslib::signal<void (bool seaLevel)> signal_airTemperatureAltitudeIsSeaLevelChanged;
      boost::signalslib::signal<void (bool seaLevel)> signal_airPressureAltitudeIsSeaLevelChanged;
      boost::signalslib::signal<void (float water)> signal_seaLevelWaterConcentrationChanged;

      //Signaled when marine states change.
      boost::signalslib::signal<void (DtDouglasSeaState::Scale seastate)> signal_seaStateChanged;
      boost::signalslib::signal<void (float radians)> signal_seaStateDirectionChanged;
      boost::signalslib::signal<void (bool enabled)> signal_windDrivenSeaStateChanged;
      boost::signalslib::signal<void (DtDouglasSwellState::Scale swellstate)> signal_swellStateChanged;
      boost::signalslib::signal<void (float radians)> signal_swellStateDirectionChanged;
      boost::signalslib::signal<void (float distance)> signal_windFetchChanged;
      boost::signalslib::signal<void (float chop)> signal_seaChoppinessChanged;
      boost::signalslib::signal<void (bool enable)> signal_underwaterVisibilityEnabledChanged;
      boost::signalslib::signal<void (double meters)> signal_underwaterVisibilityChanged;
      boost::signalslib::signal<void (double normalizedValue)> 
         signal_waterSurfaceTransparencyChanged;
      boost::signalslib::signal<void (double meters)> signal_surgeDepthChanged;
      boost::signalslib::signal<void (double meters)> signal_depthOffsetChanged;

      boost::signalslib::signal<void (float kelvins)> signal_ambientWaterTemperatureChanged;
      boost::signalslib::signal<void (float speed)> signal_waterCurrentSpeedChanged;
      boost::signalslib::signal<void (float direction)> signal_waterCurrentDirectionChanged;
      boost::signalslib::signal<void (float meters)> signal_tidalOffsetChanged;
      boost::signalslib::signal<void (bool inOut)> signal_tidalDirectionChanged;
      boost::signalslib::signal<void (unsigned int layer, float depth)> 
         signal_thermoclineDepthChanged;
      boost::signalslib::signal<void (unsigned int layer, float permeability)> 
         signal_thermoclinePermeabilityChanged;
      boost::signalslib::signal< void(const std::string& environmentName) >
         signal_environmentChanged;
      boost::signalslib::signal<void(float depth)> signal_groundSnowAccumulationChanged;
      boost::signalslib::signal<void(float depth)> signal_roadSnowAccumulationChanged;
      boost::signalslib::signal<void(float elevation)> signal_snowMinimumElevationChanged;
      boost::signalslib::signal<void(float elevation)> signal_snowElevationTransitionChanged;
      boost::signalslib::signal<void(float depth)> signal_groundRainAccumulationChanged;

   protected:
      DtEnvironmentSignaler();
   };

   class DT_DLL_VRVCORE DtWeatherProcessorSignaler : public DtVirtualBaseClass
   {
   public:
      static DtWeatherProcessorSignaler& instance(const DtSharedSettingsManager& ssm);

      static DtWeatherProcessorSignaler& instance(DtEventQueueInterface& eqi);

      static DtWeatherProcessorSignaler* findInstance(DtEventQueueInterface* eqi);

      virtual ~DtWeatherProcessorSignaler();

      event_signal< void()  > signal_refreshRemoteWeather;

   protected:
      DtWeatherProcessorSignaler(DtEventQueueInterface& eqi);

   private:
      DtWeatherProcessorSignaler(const DtWeatherProcessorSignaler&);
      DtWeatherProcessorSignaler& operator=(const DtWeatherProcessorSignaler&);
   };

   typedef DtRecordSettingsBackup<DtEnvironment, makArchives::DtEnvironmentRecord> DtEnvironmentSettingsBackup;
}