DtEnvironmentRecord.h

Go to the documentation of this file.

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


#pragma once

#include <makArchives/makArchives.h>

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

#include <string>
#include <vector>

namespace makArchives
{
   enum class BlowingParticulateMatterType : unsigned int
   {
      None = 0,
      Sand = 1,
      Snow = 2,
      Dust = 3,
   };

   enum class VisibilityObscurant : unsigned int
   {
      None = 0,
      Haze,
      Mist,
      Fog,
      Smoke,
      VolcanicAsh,
      Dust,
      Sand
   };

   class DT_DLL_MAKARCHIVES DtEnvironmentRecord
   {
   public:
      class DT_DLL_MAKARCHIVES DtColorRecord
      {
      public:
         DtColorRecord(float r=1.0f, float g=1.0f, float b=1.0f, float a=1.0f);

         DtColorRecord(const DtColorRecord& orig);

         DtColorRecord& operator =(DtColorRecord rhs);

         bool operator ==(const DtColorRecord& rhs) const;

         bool operator !=(const DtColorRecord& rhs) const;

         ~DtColorRecord();

         void swap(DtColorRecord& other);

         void setRed(float r);
         float red() const;

         void setGreen(float g);
         float green() const;

         void setBlue(float b);
         float blue() const;

         void setAlpha(float a);
         float alpha() const;

      protected:

         friend class boost::serialization::access;

         template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
            ar & BOOST_SERIALIZATION_NVP(myRed);
            ar & BOOST_SERIALIZATION_NVP(myGreen);
            ar & BOOST_SERIALIZATION_NVP(myBlue);
            ar & BOOST_SERIALIZATION_NVP(myAlpha);
         }

      protected:
         static float clamp(float component);

      protected:
         float myRed;
         float myGreen;
         float myBlue;
         float myAlpha;
      };

      class DT_DLL_MAKARCHIVES DtThermoclineRecord
      {
      public:
         DtThermoclineRecord(float depth=0.0f, float permeability=0.0);

         DtThermoclineRecord(const DtThermoclineRecord& orig);

         DtThermoclineRecord& operator =(DtThermoclineRecord rhs);

         ~DtThermoclineRecord();

         void swap(DtThermoclineRecord& other);

         void setDepth(float meters);
         float depth() const;

         void setPermeability(float normalizedValue);
         float permeability() const;

      protected:

         friend class boost::serialization::access;

         template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
            ar & BOOST_SERIALIZATION_NVP(myDepth);
            ar & BOOST_SERIALIZATION_NVP(myPermeability);
         }

      protected:
         float myDepth;
         float myPermeability;
      };

      class DT_DLL_MAKARCHIVES DtElevationalWindRecord
      {
      public:
         DtElevationalWindRecord(float mslAltitudeInMeters = 0.0f,
            float speedInMetersPerSecond = 0.0,
            float offsetInRadiansFromTrueNorth = 0.0);

         DtElevationalWindRecord(const DtElevationalWindRecord& orig);

         DtElevationalWindRecord& operator =(DtElevationalWindRecord rhs);

         ~DtElevationalWindRecord();

         void swap(DtElevationalWindRecord& other);

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

         void setWindDirection(float offsetInRadiansFromTrueNorth);
         float windDirection() const;

         void setBaseMSLAltitude(float mslAltitudeInMeters);
         float baseMSLAltitude() const;

      protected:

         friend class boost::serialization::access;

         template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
            ar & BOOST_SERIALIZATION_NVP(myBaseMSLAltitude);
            ar & BOOST_SERIALIZATION_NVP(myWindSpeed);
            ar & BOOST_SERIALIZATION_NVP(myWindDirection);
         }

      protected:
         float myBaseMSLAltitude;
         float myWindSpeed;
         float myWindDirection;
      };

      class DT_DLL_MAKARCHIVES DtElevationalConfigurationRecord
      {
      public:
         DtElevationalConfigurationRecord( float mslAltitudeInMeters = 0.0f,
            float speedInMetersPerSecond = 0.0,
            float offsetInRadiansFromTrueNorth = 0.0,
            float visibilityDistanceInMeters = 20000,
            VisibilityObscurant visibilityObscurant = VisibilityObscurant::Haze,
            const std::string& cloudTypeName = "None",
            float cloudDensity = 0.0,
            float skyCoverageInOktas = 0.0);

         DtElevationalConfigurationRecord(const DtElevationalConfigurationRecord& orig);

         DtElevationalConfigurationRecord& operator =(DtElevationalConfigurationRecord rhs);

         ~DtElevationalConfigurationRecord();

         void swap(DtElevationalConfigurationRecord& other);

         void setBaseMSLAltitude(float mslAltitudeInMeters);
         float baseMSLAltitude() const;

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

         void setWindDirection(float offsetInRadiansFromTrueNorth);
         float windDirection() const;

         void setVisibilityDistance(float visibilityInMeters);
         float visibilityDistance() const;

         void setObscurant(VisibilityObscurant obscurantEnumerationValue);
         VisibilityObscurant obscurant() const;

         void setCloudType(const std::string& cloudTypeEnumerationValue);
         std::string cloudType() const;

         void setCloudDensity(float cloudDensity);
         float cloudDensity() const;

         void setSkyCoverage(float skyCoverage);
         float skyCoverage() const;

         const DtCloudLayerRecord& cloudLayerRecord() const;

         DtCloudLayerRecord& cloudLayerRecord();

      protected:

         friend class boost::serialization::access;

         template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
            ar & BOOST_SERIALIZATION_NVP(myBaseMSLAltitude);
            ar & BOOST_SERIALIZATION_NVP(myWindSpeed);
            ar & BOOST_SERIALIZATION_NVP(myWindDirection);
            ar & BOOST_SERIALIZATION_NVP(myVisibilityDistance);
            ar & BOOST_SERIALIZATION_NVP(myObscurant);

            if (version >= 1)
            {
               ar & BOOST_SERIALIZATION_NVP(myCloudLayer);

               // force the altitudes, of the elevational record and its child
               // cloud layer record, to be the same
               myCloudLayer.setPosition(0.0, 0.0, myBaseMSLAltitude);
            }
         }

      protected:
         float myBaseMSLAltitude;
         float myWindSpeed;
         float myWindDirection;

         float myVisibilityDistance;
         VisibilityObscurant myObscurant;

         DtCloudLayerRecord myCloudLayer;
      };

      typedef std::vector<DtCloudLayerRecord> CloudLayerRecordList;
      typedef std::vector<DtThermoclineRecord> ThermoclineRecordList;
      typedef std::vector<DtElevationalWindRecord> ElevationalWindRecordList; // deprecated
      typedef std::vector<DtElevationalConfigurationRecord> ElevationalConfigurationRecordList;
      typedef std::map<std::string, std::string> OptionalParameterMap;

      DtEnvironmentRecord();

      DtEnvironmentRecord(const DtEnvironmentRecord& orig);

      virtual ~DtEnvironmentRecord();

      void swap(DtEnvironmentRecord& other);

      DtEnvironmentRecord& operator =(DtEnvironmentRecord rhs);

      void setEnvironmentName(const std::string& name);
      const std::string& environmentName() const;

      void setIsLocalOnly(bool isLocalOnly);
      bool isLocalOnly() const;

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

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

      void setPrecipitation(int type);
      int precipitation() const;

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

      CloudLayerRecordList& customCloudLayers();
      const CloudLayerRecordList& customCloudLayers() const;         

      void setCloudCoverType( DtCloudCoverType cloudCoverType );
      DtCloudCoverType cloudCoverType() const;

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

      virtual void setBlowingParticulateMatter(makArchives::BlowingParticulateMatterType type);
      virtual makArchives::BlowingParticulateMatterType blowingParticulateMatter() const;

      ElevationalConfigurationRecordList& elevationalConfigurations();
      const ElevationalConfigurationRecordList& elevationalConfigurations() const;

      virtual void addElevationalConfigurationRecord(DtElevationalConfigurationRecord rec);

      virtual bool removeElevationalConfigurationRecord(unsigned int index);

      bool setElevationalConfigurationRecord(
         unsigned int index, const DtElevationalConfigurationRecord& wRec);

      const DtElevationalConfigurationRecord* getElevationalConfigurationRecord(unsigned int index) const;

      DtElevationalConfigurationRecord* getElevationalConfigurationRecord(unsigned int index);
      
      bool setElevationalConfigurationBaseMSLAltitude(unsigned int index, float baseMSLAltitude);
      
      bool getElevationalConfigurationBaseMSLAltitude(unsigned int index, float& baseMSLAltitude) const;

      bool setElevationalWindSpeed(unsigned int index, float metersPerSecond);
      
      bool getElevationalWindSpeed(unsigned int index, float& windSpeed) const;

      bool setElevationalWindDirection(unsigned int index, float radiansFromNorth);
      
      bool getElevationalWindDirection(unsigned int index, float& windDirection) const;

      bool setElevationalVisibilityDistance(unsigned int index, float meters);

      bool getElevationalVisibilityDistance(unsigned int index, float& visibilityDistance) const;

      bool setElevationalVisibilityObscurant(unsigned int index, VisibilityObscurant obscurant);

      bool getElevationalVisibilityObscurant(unsigned int index, VisibilityObscurant& obscurant) const;

      bool setElevationalCloudType(unsigned int index, std::string cloudTypeName);

      bool getElevationalCloudType(unsigned int index, std::string& cloudTypeName) const;

      bool setElevationalCloudDensity(unsigned int index, float cloudDensity);

      bool getElevationalCloudDensity(unsigned int index, float& cloudDensity) const;

      bool setElevationalSkyCoverage(unsigned int index, float cloudCoverage);

      bool getElevationalSkyCoverage(unsigned int index, float& cloudCoverage) const;

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

      void setWindDirection(float radiansFromNorth);
      float windDirection() const;

      void setAmbientAirTemperature(float kelvins);
      float ambientAirTemperature() const;

      void setSeaState(int douglasScale);
      int seaState() const;

      void setSeaStateDirection(float radiansFromNorth);
      float seaStateDirection() const;

      void setWindDrivenSeaStateEnabled(bool enabled);
      bool windDrivenSeaStateEnabled() const;

      void setSwellState(int douglasScale);
      int swellState() const;

      void setSwellStateDirection(float radiansFromNorth);
      float swellStateDirection() const;

      void setWindFetch(float meters);
      float windFetch() const;

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

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

      void setUnderwaterVisibility(float meters);
      float underwaterVisibility() const;

      void setSurfaceTransparency(float normalizedValue);
      float surfaceTransparency() const;

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

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

      void setAmbientWaterTemperature(float kelvins);
      float ambientWaterTemperature() const;

      void setWaterCurrentSpeed(float metersPerSecond);
      float waterCurrentSpeed() const;

      void setWaterCurrentDirection(float radiansFromNorth);
      float waterCurrentDirection() const;

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

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

      void setFogHeight(float meters);
      float fogHeight() const;

      void setFogColor(const DtColorRecord& color);
      const DtColorRecord& fogColor() const;

      void setThermoclineRecord(
         unsigned int index, const DtThermoclineRecord& tRec);
      DtThermoclineRecord thermoclineRecord(unsigned int index) const;
      void setThermoclineDepth(unsigned int index, float depth);
      float thermoclineDepth(unsigned int index) const;
      void setThermoclinePermeability(unsigned int index, float permeability);
      float thermoclinePermeability(unsigned int index) const;

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

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

      void setSnowMinimumElevation(float elevation);
      float snowMinimumElevation() const;

      void setSnowElevationTransition(float elevation);
      float snowElevationTransition() const;

      void setGroundRainAccumulation(float depth);
      float groundRainAccumulation() const;

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

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

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

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

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

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

      virtual const std::string*
         findOptionalParameter(const std::string& name) const;

      virtual void setOptionalParameter(
         const std::string& name, const std::string& value);

      virtual void setOptionalParameters(const OptionalParameterMap&);

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

      const OptionalParameterMap& optionalParameters() const;

   protected:

      virtual void sortElevationalWindRecordsByBaseMSLAltitude();

      virtual void sortElevationalConfigurationRecordsByBaseMSLAltitude();
      
      virtual void copyOldWindSpecificElevationalConfigurationsToNewElevationalConfigurations();

      friend class boost::serialization::access;

      template<class Archive>
      void serialize(Archive & ar, const unsigned int version)
      {
         ar & BOOST_SERIALIZATION_NVP(myAirTurbidity);
         
         if (version < 12)
         {
            ar & BOOST_SERIALIZATION_NVP(myVisibilityDistance);

            bool foundConfig = false;
            for (auto& config : elevationalConfigurations())
            {
               // search for config at base MSL altitude 0.0
               if (config.baseMSLAltitude() < 0.0001f && config.baseMSLAltitude() > -0.0001f)
               {
                  // found config
                  config.setVisibilityDistance(myVisibilityDistance);
                  foundConfig = true;
               }
            }

            if (!foundConfig)
            {
               // never found config for base MSL altitude 0.0, add one
               DtElevationalConfigurationRecord newRec(0.0f, 0.0f, 0.0f, myVisibilityDistance);
               addElevationalConfigurationRecord(newRec);
            }
         }
         else
         {
            ar & BOOST_SERIALIZATION_NVP(myElevationalConfigurations);

            for (auto& config : elevationalConfigurations())
            {
               // search for config at base MSL altitude 0.0
               if (config.baseMSLAltitude() < 0.0001f && config.baseMSLAltitude() > -0.0001f)
               {
                  // found config
                  myVisibilityDistance = config.visibilityDistance();
               }
            }
         }

         if (version < 4)
         {
            ar & BOOST_SERIALIZATION_NVP(myPrecipitationEnabledFlag);
            ar & BOOST_SERIALIZATION_NVP(myPrecipitationType);
            if (myPrecipitationEnabledFlag && myPrecipitationType == "Rain")
            {
               myPrecipitation = 1;
            }
            else if (myPrecipitationEnabledFlag && myPrecipitationType == "Snow")
            {
               myPrecipitation = 2;
            }
            else
            {
               myPrecipitationType = "None";
               myPrecipitation = 0;
            }
         }
         ar & BOOST_SERIALIZATION_NVP(myPrecipitationIntensity);
         ar & BOOST_SERIALIZATION_NVP(myCloudLayers);
         if (version < 11)
         {
            ar & BOOST_SERIALIZATION_NVP(myWindSpeed);
            ar & BOOST_SERIALIZATION_NVP(myWindDirection);
            
            bool foundConfig = false;
            for (auto& config : elevationalConfigurations())
            {
               // search for config at base MSL altitude 0.0
               if (config.baseMSLAltitude() < 0.0001f && config.baseMSLAltitude() > -0.0001f)
               {
                  // found config
                  config.setWindSpeed(myWindSpeed);
                  config.setWindDirection(myWindDirection);
                  foundConfig = true;
               }
            }

            if (!foundConfig)
            {
               // never found config for base MSL altitude 0.0, add one
               DtElevationalConfigurationRecord newRec(0.0f, myWindSpeed, myWindDirection);
               addElevationalConfigurationRecord(newRec);
            }
         }
         else if (version == 11)
         {
            ar & BOOST_SERIALIZATION_NVP(myWindConfigurations);
            copyOldWindSpecificElevationalConfigurationsToNewElevationalConfigurations();
         }
         if(version >= 1)
         {
            ar & BOOST_SERIALIZATION_NVP(myAmbientAirTemperature);
            ar & BOOST_SERIALIZATION_NVP(mySeaState);
            ar & BOOST_SERIALIZATION_NVP(mySeaChoppiness);
            ar & BOOST_SERIALIZATION_NVP(myUnderwaterVisibility);
            ar & BOOST_SERIALIZATION_NVP(myAmbientWaterTemperature);
            ar & BOOST_SERIALIZATION_NVP(myWaterCurrentSpeed);
            ar & BOOST_SERIALIZATION_NVP(myWaterCurrentDirection);
            ar & BOOST_SERIALIZATION_NVP(myTidalOffset);
            ar & BOOST_SERIALIZATION_NVP(myTidalDirection);
         }
         if (version >= 2)
         {
            ar & BOOST_SERIALIZATION_NVP(myEnvironmentName);
            if (version >= 14)
            {
               ar & BOOST_SERIALIZATION_NVP(myIsLocalOnly);
            }
            ar & BOOST_SERIALIZATION_NVP(myOptionalParameters);
         }
         if (version >= 3)
         {
            ar & BOOST_SERIALIZATION_NVP(mySeaStateDirection);
            ar & BOOST_SERIALIZATION_NVP(myWindDrivenSeaStateEnabled);
            ar & BOOST_SERIALIZATION_NVP(mySwellState);
            ar & BOOST_SERIALIZATION_NVP(mySwellStateDirection);
            ar & BOOST_SERIALIZATION_NVP(myWindFetch);
            ar & BOOST_SERIALIZATION_NVP(mySurfaceTransparency);
            ar & BOOST_SERIALIZATION_NVP(mySurgeDepth);
            ar & BOOST_SERIALIZATION_NVP(myDepthOffset);
         }
         if (version >= 4)
         {
            ar & BOOST_SERIALIZATION_NVP(myFogHeight);
            ar & BOOST_SERIALIZATION_NVP(myFogColor);
            ar & BOOST_SERIALIZATION_NVP(myPrecipitation);
            ar & BOOST_SERIALIZATION_NVP(myThermoclineRecordList);
         }
         if (version >= 5)
         {
            ar & BOOST_SERIALIZATION_NVP(myCloudCoverType);
            if (version < 7)
            {
               ar & BOOST_SERIALIZATION_NVP(myUseCustomCloudCover);
            }
         }
         if (version >= 6)
         {
            ar & BOOST_SERIALIZATION_NVP(myUnderwaterVisibilityEnabled);
         }
         if (version >= 8)
         {
            ar & BOOST_SERIALIZATION_NVP(myGroundSnowAccumulation);
            ar & BOOST_SERIALIZATION_NVP(myRoadSnowAccumulation);
            ar & BOOST_SERIALIZATION_NVP(mySnowMinimumElevation);
            ar & BOOST_SERIALIZATION_NVP(mySnowElevationTransition);
         }
         if (version >= 9)
         {
            ar & BOOST_SERIALIZATION_NVP(myGroundRainAccumulation);
         }
         if (version >= 10)
         {
            ar & BOOST_SERIALIZATION_NVP(myAirPressure);
         }
         if (version >= 12)
         {
            ar & BOOST_SERIALIZATION_NVP(myAirPressureAltitude);
            ar & BOOST_SERIALIZATION_NVP(myAirTemperatureAltitude);
            ar & BOOST_SERIALIZATION_NVP(myAirPressureAltitudeIsSeaLevel);
            ar & BOOST_SERIALIZATION_NVP(myAirTemperatureAltitudeIsSeaLevel);
            ar & BOOST_SERIALIZATION_NVP(mySeaLevelWaterConcentration);
         }
         if (version >= 13)
         {
            ar & BOOST_SERIALIZATION_NVP(myLightningPresent);
         }

         if (version >= 15)
         {
            ar& BOOST_SERIALIZATION_NVP(myBlowingParticulateMatter);
         }
      }

      std::string myEnvironmentName;
      bool myIsLocalOnly;

      float myAirTurbidity;
      int myPrecipitation;
      float myPrecipitationIntensity;
      CloudLayerRecordList myCloudLayers;
      DtCloudCoverType myCloudCoverType;
      bool myLightningPresent;

      BlowingParticulateMatterType myBlowingParticulateMatter;

      // Old Wind Speed and Wind Direction - Needed to support versions < 11
      float myWindSpeed;
      float myWindDirection;

      // Old Global Visibility - Needed to support versions < 12
      float myVisibilityDistance;

      // Old Wind-Specific Elevational Configuration - Needed to support version 11
      ElevationalWindRecordList myWindConfigurations;

      // New Elevational (versions >= 12):
      // - Wind Speed and Wind Direction
      // - Visibility Distance and Obscurant
      ElevationalConfigurationRecordList myElevationalConfigurations;

      float myAmbientAirTemperature;

      int mySeaState;
      float mySeaStateDirection;
      bool myWindDrivenSeaStateEnabled;
      int mySwellState;
      float mySwellStateDirection;
      float myWindFetch;
      float mySeaChoppiness;
      float myUnderwaterVisibility;
      float mySurfaceTransparency;
      float mySurgeDepth;
      float myDepthOffset;

      float myAmbientWaterTemperature;
      float myWaterCurrentSpeed;
      float myWaterCurrentDirection;
      float myTidalOffset;
      bool myTidalDirection;

      float myFogHeight;
      DtColorRecord myFogColor;

      ThermoclineRecordList myThermoclineRecordList;
      // obsolete as of version 7 (it was never actually used)
      bool myUseCustomCloudCover;

      OptionalParameterMap myOptionalParameters;

      // obsolete as of version 4
      bool myPrecipitationEnabledFlag;
      std::string myPrecipitationType;

      bool myUnderwaterVisibilityEnabled;
      
      float myGroundSnowAccumulation;
      float myRoadSnowAccumulation;
      float mySnowMinimumElevation;
      float mySnowElevationTransition;
      float myGroundRainAccumulation;

      float myAirPressure;

      float myAirPressureAltitude;
      float myAirTemperatureAltitude;
      bool myAirPressureAltitudeIsSeaLevel;
      bool myAirTemperatureAltitudeIsSeaLevel;
      float mySeaLevelWaterConcentration;
   };

}

BOOST_CLASS_VERSION(makArchives::DtEnvironmentRecord::DtColorRecord, 0)
BOOST_CLASS_VERSION(makArchives::DtEnvironmentRecord::DtThermoclineRecord, 0)
BOOST_CLASS_VERSION(makArchives::DtEnvironmentRecord::DtElevationalWindRecord, 0)
BOOST_CLASS_VERSION(makArchives::DtEnvironmentRecord::DtElevationalConfigurationRecord, 1)
BOOST_CLASS_VERSION(makArchives::DtEnvironmentRecord, 15)