DtEnvironment.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtRecordSettingsBackup.h>

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

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

namespace makArchives
{
   class DtCloudLayerRecord;
   class DtEnvironmentRecord;
}

namespace makVrv
{
   class DtDe;
   class DtAgentManagerInterface;
   class DtSkyObjectAgent;
   class DtEventQueueInterface;
   class DtSharedSettingsManager;

   class DT_DLL_VRVCORE DtEnvironment
   {
   public:

      enum PrecipitationType
      {
         Rain = 0,
         Snow = 1
      };

      DtEnvironment(DtDe& de, DtAgentManagerInterface& sceneInterface);

      ~DtEnvironment();

      void clear();

      void getRecord(makArchives::DtEnvironmentRecord& record);

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

      void addCloudLayer(const makArchives::DtCloudLayerRecord& record);

      void setCloudLayerEnabled(unsigned int index, bool enabled);

      void setCloudLayerPosition(unsigned int index, double xCoord, double yCoord);
      
      void removeCloudLayer(unsigned int index);

      void setAirTurbidity(float turbidity);

      void setVisibleDistance(float distance);

      void setPrecipitationEnabled(bool enabled);

      void setPrecipitationType(PrecipitationType type);

      void setPrecipitationIntensity(float intensity);

      void setWindSpeed(float speed);

      void setWindDirection(float direction);

      void setAmbientAirTemperature(float temperature);

      void setSeaState(int state);

      void setSeaChoppiness(float chop);

      void setUnderwaterVisibility(float distance);

      void setAmbientWaterTemperature(float temperature);

      void setWaterCurrentSpeed(float speed);

      void setWaterCurrentDirection(float direction);

      void setTidalOffset(float meters);

      void setTidalDirection(bool inOut);


      const makArchives::DtEnvironmentRecord& settings() const;   

      //Helper Function
      static int translateCloudTypeStringToEnum(const std::string& str);

      //Helper Function
      static  std::string translateCloudTypeEnumToString(int id);

      //Called from CTOR to load the default settings.
      void loadDefaults(bool loadOnlyFactorySettings = false);

      // Restores to backup up environment from startup default
      void restore();

      //Called to save the current settings as the default settings.
      void saveAsDefaults();

      void exportSettings(const std::string& fileName);
      void importSettings(const std::string& fileName);

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

      DtSettingsBackup* settingsBackup()
      {
         return mySettingsBackup;
      }
   protected:

      virtual void slot_coordinateSystemChanged( const std::string&, const std::string& );

   protected:

      DtDe& myDe;
      DtAgentManagerInterface& mySceneInterface;

      makArchives::DtEnvironmentRecord* mySettings;

      DtSkyObjectAgent* mySkyObject;
      DtRecordSettingsBackupInterface*  mySettingsBackup;
      DtSignalConnectionManager myConnections;

   };

   class DT_DLL_VRVCORE DtEnvironmentSignaler : public DtVirtualBaseClass
   {
   public:

      static DtEnvironmentSignaler& instance(DtDe& de);

      virtual ~DtEnvironmentSignaler();

      //Signaled when any of the atmospheric parameters change.
      boost::signal<void ()> signal_atmosphericParametersChanged;
      
      //Signaled when any of the precipitation parameters change.
      boost::signal<void ()> signal_precipitationSettingsChanged;

      boost::signal<void (int index)> signal_cloudLayerAdded;
      boost::signal<void (int index)> signal_cloudLayerToBeDestroyed;
      boost::signal<void (int index, bool enabled)> signal_cloudLayerEnabledChanged;

      //Signaled when air parameters change.
      boost::signal<void (float speed)> signal_windSpeedChanged;
      boost::signal<void (float direction)> signal_windDirectionChanged;
      boost::signal<void (float celsius)> signal_ambientAirTemperatureChanged;

      //Signaled when marine states change.
      boost::signal<void (unsigned int seastate)> signal_seaStateChanged;
      boost::signal<void (float chop)> signal_seaChoppinessChanged;
      boost::signal<void (double meters)> signal_underwaterVisibilityChanged;
      boost::signal<void (float celsius)> signal_ambientWaterTemperatureChanged;
      boost::signal<void (float speed)> signal_waterCurrentSpeedChanged;
      boost::signal<void (float direction)> signal_waterCurrentDirectionChanged;
      boost::signal<void (float meters)> signal_tidalOffsetChanged;
      boost::signal<void (bool inOut)> signal_tidalDirectionChanged;

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