DtEnvironmentInterface.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/DtSkyObject.h>

#include <vrvUtil/DtCloudTypeMapper.h>
#include <vrvUtil/DtDouglasSeaScale.h>

#include <makArchives/DtEnvironmentRecord.h>

#include <string>
#include <vector>

#include <matrix/vlVector.h>

namespace makArchives
{
   class DtCloudLayerRecord;
}

namespace makVrv
{
   class DtDe;
   class DtAgentManagerInterface;
   class DtSettingsBackup;
   class DtOceanLayer;
   class DtCloudLayer;

   class DT_DLL_VRVCORE DtEnvironmentInterface
   {
   public:

      typedef enum
      {
         None = DtSkyObject::None, 
         Rain = DtSkyObject::Rain, 
         Snow = DtSkyObject::SnowWet, 
         Hail = DtSkyObject::Hail,
         Sleet = DtSkyObject::Sleet,
         Drizzle = DtSkyObject::Drizzle,
      } PrecipitationType;

      typedef makArchives::BlowingParticulateMatterType BlowingParticulateMatterType;
      typedef makArchives::VisibilityObscurant VisibilityObscurant;
      typedef makArchives::DtEnvironmentRecord::DtElevationalConfigurationRecord DtElevationalConfigurationRecord;

      typedef DtCloudTypeMapper::CloudType CloudType;

      const static std::string theRemoteEnvironmentName;
      
      const static float theMaximumVisibilityDistance;

      DtEnvironmentInterface();

      virtual ~DtEnvironmentInterface();

      virtual void getRecord(makArchives::DtEnvironmentRecord& record) const = 0;

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

      virtual void saveEnvironment(const std::string& envName) = 0;

      virtual void removeEnvironment(const std::string& envName) = 0;

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

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

      virtual void setEnvironment(const std::string& envName) = 0;

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

      virtual std::string defaultEnvironmentName() const = 0;

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

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

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

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

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

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

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

      virtual void updateOrAddElevationalConfiguration(const DtElevationalConfigurationRecord& record) = 0;

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

      virtual void removeElevationalConfiguration(float baseMSLAltitude) = 0;

      virtual void moveElevationalConfiguration(
         float oldBaseMSLAltitude, float newBaseMSLAltitude) = 0;

      virtual void setWindSpeedAtMSLAltitude(float mslAltitude, float windSpeed) = 0;

      virtual float windSpeedAtMSLAltitude(float mslAltitude) const = 0;

      virtual void setWindDirectionAtMSLAltitude(float mslAltitude, float windDirection) = 0;

      virtual float windDirectionAtMSLAltitude(float mslAltitude) const = 0;

      virtual void setVisibilityDistanceAtMSLAltitude(float mslAltitude, float visibilityDistance) = 0;

      virtual float visibilityDistanceAtMSLAltitude(float mslAltitude) const = 0;

      virtual void setObscurantAtMSLAltitude(float mslAltitude, VisibilityObscurant obscurant) = 0;

      virtual VisibilityObscurant obscurantAtMSLAltitude(float mslAltitude) const = 0;

      virtual void setCloudTypeAtMSLAltitude(float mslAltitude, CloudType cloudType) = 0;

      virtual CloudType cloudTypeAtMSLAltitude(float mslAltitude) const = 0;

      virtual void setSkyCoverageAtMSLAltitude(float mslAltitude, float skyCoverage) = 0;

      virtual float skyCoverageAtMSLAltitude(float mslAltitude) const = 0;

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

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

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

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

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

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

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

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

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

      virtual void setGroundFogColor(const DtVector& color) = 0;
      virtual DtVector groundFogColor() const = 0;

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

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

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

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

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

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

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

      virtual void setUnderwaterVisibilityEnabled(bool enabled) = 0;
      virtual bool underwaterVisibilityEnabled() const = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

      virtual void setSnowMinimumElevation(float elevation) = 0;
      virtual float snowMinimumElevation() const = 0;

      virtual void setSnowElevationTransition(float elevation) = 0;
      virtual float snowElevationTransition() const = 0;

      virtual void setGroundRainAccumulation(float depth) = 0;
      virtual float groundRainAccumulation() const = 0;

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

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

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

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

   protected:


      virtual void slot_coordinateSystemChanged() = 0;

      virtual void slot_oceanLayerAdded(const DtOceanLayer& layer) = 0;

      virtual void slot_oceanLayerToBeDeleted(const DtOceanLayer& layer) = 0;

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

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

      virtual void slot_surgeDepthChanged(double depth) = 0;

      virtual void slot_depthOffsetChanged(double offset) = 0;
   
   };
}