DtEnvironmentRecord.h

Go to the documentation of this file.

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


#pragma once

#include <makArchives/makArchives.h>

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

namespace makArchives
{
   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);

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

      private:
         static float clamp(float component);

      private:
         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);
         }

      private:
         float myDepth;
         float myPermeability;
      };

      typedef std::vector<DtCloudLayerRecord> CloudLayerRecordList;
      typedef std::vector<DtThermoclineRecord> ThermoclineRecordList;
      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 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;

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

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

      void setAmbientAirTemperature(float celsius);
      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 celsius);
      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;

      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:

      friend class boost::serialization::access;

      template<class Archive>
      void serialize(Archive & ar, const unsigned int version)
      {
         ar & BOOST_SERIALIZATION_NVP(myAirTurbidity);
         ar & BOOST_SERIALIZATION_NVP(myVisibilityDistance);
         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 >= 1)
         {
            ar & BOOST_SERIALIZATION_NVP(myWindSpeed);
            ar & BOOST_SERIALIZATION_NVP(myWindDirection);
            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);
            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);
         }
      }

      std::string myEnvironmentName;

      float myAirTurbidity;
      float myVisibilityDistance;
      int myPrecipitation;
      float myPrecipitationIntensity;
      CloudLayerRecordList myCloudLayers;
      DtCloudCoverType myCloudCoverType;
      float myWindSpeed;
      float myWindDirection;
      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;

   };

}

BOOST_CLASS_VERSION(makArchives::DtEnvironmentRecord::DtColorRecord, 0)
BOOST_CLASS_VERSION(makArchives::DtEnvironmentRecord::DtThermoclineRecord, 0)
BOOST_CLASS_VERSION(makArchives::DtEnvironmentRecord, 9)