DtEnvironmentStatusManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>

#include <vrvCore/DtGlobalLayeredEnvironmentData.h>
#include <vrvCore/DtLocalLayeredEnvironmentData.h>

#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtEnvironment.h>

#include <vrvUtil/DtVirtualBaseClass.h>

#include <makArchives/DtEnvironmentRecord.h>

#include <unordered_map>

namespace makArchives
{
   enum class VisibilityObscurant : unsigned int;
}

namespace makVrv
{
   class DtBaseConnection;
   class DtSceneEnvironmentalsControllerObjectAgent;
   class DtLocalEnvironmentalsControllerObjectAgent;

   class DT_DLL_VRVCORE DtEnvironmentStatusManager : public DtVirtualBaseClass
   {
   public:
      // Often used as a 'default' value for DtUniqueIDs, it is assumed that the 
      // DtAgentManagerInterface::createNewUniqueId() will not return this value
      static const DtUniqueID GlobalWeatherAreaId = (DtUniqueID)-1;

   protected:
      class DtSubsurfaceRecord
      {
         public:
            DtSubsurfaceRecord() 
               : myPermeability(-1.)
               , myVisibility(-1.)
            {
               // Intentional No-op
            }

            ~DtSubsurfaceRecord() 
            {
               // Intentional No-op
            }

            DtSubsurfaceRecord(const DtSubsurfaceRecord& orig)
            : myPermeability(orig.myPermeability)
            , myVisibility(orig.myVisibility)
            {
               // Intentional No-op
            }

            DtSubsurfaceRecord& operator=(const DtSubsurfaceRecord& rhs)
            {
               if (this != &rhs)
               {
                  myPermeability = rhs.myPermeability;
                  myVisibility = rhs.myVisibility;
               }
               return *this;
            }

            float permeability() const
            {
               return myPermeability;
            }

            void setPermeability(float val)
            {
               myPermeability = val;
            }

            float visibility() const
            {
               return myVisibility;
            }

            void setVisibility(float val)
            {
               myVisibility = val;
            }

         protected:
            float myPermeability;
            float myVisibility;
      };

   public:
      DtEnvironmentStatusManager(DtBaseConnection& conn);

      DtEnvironmentStatusManager() = delete;
      
      virtual ~DtEnvironmentStatusManager();

      DtEnvironmentStatusManager(const DtEnvironmentStatusManager&) = delete;

      DtEnvironmentStatusManager& operator=(const DtEnvironmentStatusManager&) = delete;

   public:
      virtual void addWeatherArea(DtUniqueID areaId);

      virtual void removeWeatherArea(DtUniqueID areaId);

      virtual void addElevationalConfiguration(DtUniqueID areaId, DtUniqueID layerId);

      virtual void removeElevationalConfiguration(DtUniqueID areaId, DtUniqueID uniqueId);

      virtual void setLocalZoneOrigin(DtUniqueID areaId, const DtVector& origin);

      virtual void setLocalZoneShape(DtUniqueID areaId, float width, float length, float height, float cornerRadius);

      virtual DtLocalLayeredEnvironmentData* findLocalWeatherArea(DtUniqueID areaId);

      virtual const DtLocalLayeredEnvironmentData* findLocalWeatherArea(DtUniqueID areaId) const;

      virtual DtGlobalLayeredEnvironmentData* globalWeatherArea();

      virtual const DtGlobalLayeredEnvironmentData* globalWeatherArea() const;

      virtual void setBaseMSLAltitude(DtUniqueID areaId, DtUniqueID layerId, float mslAltitudeInMeters);
      virtual float baseMSLAltitude(DtUniqueID areaId, DtUniqueID layerId) const;

      virtual void setWindSpeed(DtUniqueID areaId, DtUniqueID layerId, float speedInMetersPerSecond);
      virtual float windSpeed(DtUniqueID areaId, DtUniqueID layerId) const;

      virtual void setWindDirection(DtUniqueID areaId, DtUniqueID layerId, float offsetInRadiansFromTrueNorth);
      virtual float windDirection(DtUniqueID areaId, DtUniqueID layerId) const;

      virtual void setVisibilityDistance(DtUniqueID areaId, DtUniqueID layerId, float visibilityInMeters);
      virtual float visibilityDistance(DtUniqueID areaId, DtUniqueID layerId) const;

      virtual void setObscurant(DtUniqueID areaId, DtUniqueID layerId, makArchives::VisibilityObscurant obscurantEnumerationValue);
      virtual makArchives::VisibilityObscurant obscurant(DtUniqueID areaId, DtUniqueID layerId) const;

      virtual void setCloudType(DtUniqueID areaId, DtUniqueID layerId, const std::string& cloudTypeEnumerationValue);
      virtual std::string cloudType(DtUniqueID areaId, DtUniqueID layerId) const;

      virtual void setCloudDensity(DtUniqueID areaId, DtUniqueID layerId, float cloudDensity);
      virtual float cloudDensity(DtUniqueID areaId, DtUniqueID layerId) const;

      virtual void setSkyCoverage(DtUniqueID areaId, DtUniqueID layerId, float skyCoverage);
      virtual float skyCoverage(DtUniqueID areaId, DtUniqueID layerId) const;


      virtual void setPrecipitationType(DtUniqueID areaId,  DtEnvironment::PrecipitationType type);
      virtual DtEnvironment::PrecipitationType precipitationType(DtUniqueID areaId) const;

      virtual void setPrecipitationIntensity(DtUniqueID areaId, float intensity);
      virtual float precipitationIntensity(DtUniqueID areaId) const;

      virtual void setAirTemperature(DtUniqueID areaId, float temperature);
      virtual float airTemperature(DtUniqueID areaId) const;

      virtual void setAirPressure(DtUniqueID areaId, float pressure);
      virtual float airPressure(DtUniqueID areaId);

      virtual void setSeaLevelWaterConcentration(DtUniqueID areaId, float ppmv);
      virtual float seaLevelWaterConcentration(DtUniqueID areaId) const;

      virtual void setLightningPresent(DtUniqueID areaId, bool present);
      virtual bool lightningPresent(DtUniqueID areaId) const;

      virtual void setSnowMinimumElevation(DtUniqueID areaId, float elevation);
      virtual float snowMinimumElevation(DtUniqueID areaId) const;

      virtual void setRoadSnowAccumulation(DtUniqueID areaId, float accumulation);
      virtual float roadSnowAccumulation(DtUniqueID areaId) const;

      virtual void setGroundRainAccumulation(DtUniqueID areaId, float accumulation);
      virtual float groundRainAccumulation(DtUniqueID areaId) const;

      virtual void setGroundSnowAccumulation(DtUniqueID areaId, float accumulation);
      virtual float groundSnowAccumulation(DtUniqueID areaId) const;

      virtual void setFogColor(DtUniqueID areaId, float red, float green, float blue);
      virtual void getFogColor(DtUniqueID areaId, float& red, float& green, float& blue) const;

      virtual void setFogHeight(DtUniqueID areaId, float height);
      virtual float fogHeight(DtUniqueID areaId) const;

      virtual void setAirPressureAltitude(DtUniqueID areaId, float altitude);
      virtual float airPressureAltitude(DtUniqueID areaId) const;

      virtual void setAirTemperatureAltitude(DtUniqueID areaId, float altitude);
      virtual float airTemperatureAltitude(DtUniqueID areaId) const;

   // 
   // --- The following methods only apply to global environment data so no weather area id is provided
   //

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

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

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

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

      virtual void setWindDrivenSeaStateEnabled(bool value, bool force=false);
      virtual bool windDrivenSeaStateEnabled() const;

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

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

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

      virtual void setSurfaceTransparency(float value);
      virtual float surfaceTransparency() const;

      virtual void setSurgeDepth(float value);
      virtual float surgeDepth() 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 setDateAndTimeOfDay(int year, int month, int day, int hour, int minutes, double seconds);
      virtual void getDateAndTimeOfDay(int& year, int& month, int& day, int& hour, int& minutes, double& seconds);

      virtual void setUseGlobalTimeZone(bool, bool force=false);
      virtual bool useGlobalTimeZone() const;

      virtual void setTimeOfDayAdvancementSpeed(float speed);
      virtual float timeOfDayAdvancementSpeed() const;

      virtual void setThermoclinePermeability(float depth, float permeability);
      virtual float thermoclinePermeability(float depth) const;

   public:
      static DtEnvironmentStatusManager& instance(DtBaseConnection& conn);

   protected:
      virtual DtLayeredEnvironmentDataBase* findWeatherAreaBase(DtUniqueID areaId);

      virtual const DtLayeredEnvironmentDataBase* findWeatherAreaBase(DtUniqueID areaId) const;

   protected:
      DtBaseConnection& myConnection;

      std::unordered_map<DtUniqueID, DtLocalLayeredEnvironmentData*> myLocalWeatherAreasMap;
      std::unordered_map<DtUniqueID, DtLocalEnvironmentalsControllerObjectAgent*> myLocalWeatherAgentsMap;

      DtSceneEnvironmentalsControllerObjectAgent* myGlobalWeatherAgent;
      DtGlobalLayeredEnvironmentData* myGlobalWeatherArea;

      // While the local controller object will let us set thermocline info, the methods are no-ops; only
      // global thermocline layers are supported.  The key is a depth value
      std::map<float, DtSubsurfaceRecord> myGlobalThermoclineMap;
   };    
}