vrfEnvironmentalWeatherStateRecord.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2017 VT MAK
 * All rights reserved.
 ****************************************************************************/


#pragma once

#include <vrfExtObjects/dllExport.h>
#include <vl/globalObjectDesignatorList.h>
#include <vl/environmentalRecord.h>
#include <vlpi/disEnums.h>

// Definition of the FIXED PORTION of the weather state object.
// This will be followed by a variable length string of bytes to represent
// the object label, and 0 or more global object designators to represent
// any subordinate objects within the object represented.

struct DtNetWeatherStateRecord_V1
{
   DtNetEnvironmentalRecord      myHeader;
   DtNetU32                      myRecordVersion;
   DtNetFloat64                  myAirTurbidity;
   DtNetU32                      myCloudState;
   DtNetFloat64                  myPrecipitationIntensity;
   DtNetU32                      myPrecipitationType;
   DtNetFloat64                  myVisibility;
   DtNetFloat64                  myWindDirection;
   DtNetFloat64                  myWindSpeed;
   DtNetFloat64                  myIllumination;
   DtNetFloat64                  myTimeOfDay;
   DtNetFloat64                  myTimeOfDayAdvancementSpeed;
};

struct DtNetWeatherStateRecord_V2
{
   DtNetEnvironmentalRecord      myHeader;
   DtNetU32                      myRecordVersion;
   DtNetFloat64                  myAirTurbidity;
   DtNetU32                      myCloudState;
   DtNetFloat64                  myPrecipitationIntensity;
   DtNetU32                      myPrecipitationType;
   DtNetFloat64                  myVisibility;
   DtNetFloat64                  myWindDirection;
   DtNetFloat64                  myWindSpeed;
   DtNetFloat64                  myIllumination;
   DtNetFloat64                  myTimeOfDay;
   DtNetFloat64                  myTimeOfDayAdvancementSpeed;
   DtNetFloat64                  myAmbientAirTemperature;
};

struct DtNetWeatherStateRecord_V3
{
   DtNetEnvironmentalRecord      myHeader;
   DtNetU32                      myRecordVersion;
   DtNetFloat64                  myAirTurbidity;
   DtNetU32                      myCloudState;
   DtNetFloat64                  myPrecipitationIntensity;
   DtNetU32                      myPrecipitationType;
   DtNetFloat64                  myVisibility;
   DtNetFloat64                  myWindDirection;
   DtNetFloat64                  myWindSpeed;
   DtNetFloat64                  myIllumination;
   DtNetFloat64                  myTimeOfDay;
   DtNetFloat64                  myTimeOfDayAdvancementSpeed;
   DtNetFloat64                  myAmbientAirTemperature;
   DtNetFloat64                  myUnderwaterVisibility;
   DtNetFloat64                  mySurfaceTransparency;
   DtNetFloat64                  myWaterCurrentSpeed;
   DtNetFloat64                  myWaterCurrentDirection;
   DtNetFloat64                  myAmbientWaterTemperature;
   DtNetFloat64                  myTidalOffset;
   DtNetBoolean                  myTidalDirection;
   DtNetFloat64                  mySeaState;
   DtNetFloat64                  mySeaStateDirection;
   DtNetFloat64                  myWindDrivenSeaStateEnabled;
   DtNetU32                      mySwellState;
   DtNetFloat64                  mySwellStateDirection;
   DtNetFloat64                  myChoppiness;
   DtNetFloat64                  mySurgeDepth;
   DtNetFloat64                  myThermoclineLayer1Depth;
   DtNetFloat64                  myThermoclineLayer1Permeability;
   DtNetFloat64                  myThermoclineLayer2Depth;
   DtNetFloat64                  myThermoclineLayer2Permeability;
   DtNetFloat64                  myThermoclineLayer3Depth;
   DtNetFloat64                  myThermoclineLayer3Permeability;
   DtNetFloat64                  myThermoclineLayer4Depth;
   DtNetFloat64                  myThermoclineLayer4Permeability;
   DtNetFloat64                  myThermoclineLayer5Depth;
   DtNetFloat64                  myThermoclineLayer5Permeability;
};

struct DtNetWeatherStateRecordOld : public DtNetWeatherStateRecord_V3
{
   DtNetInt64                    myDateAndTimeOfDay;  // Sent in conjunction with time of day, this is date/time since 00:00 hours, Jan 1, 1970 UTC
};

// This is the revamped version of the weather state record.  The version above is just used for
// backward compatability
struct DtNetWeatherStateRecord_V4
{
   DtNetEnvironmentalRecord      myHeader;
   DtNetU32                      myRecordVersion;
   DtNetFloat64                  myAirTurbidity;
   DtNetU32                      myCloudState;
   DtNetFloat64                  myPrecipitationIntensity;
   DtNetU32                      myPrecipitationType;
   DtNetFloat64                  myVisibility;
   DtNetFloat64                  myWindDirection;
   DtNetFloat64                  myWindSpeed;
   DtNetFloat64                  myIllumination;
   DtNetFloat64                  myAmbientAirTemperature;
   DtNetFloat64                  myUnderwaterVisibility;
   DtNetFloat64                  mySurfaceTransparency;
   DtNetFloat64                  myWaterCurrentSpeed;
   DtNetFloat64                  myWaterCurrentDirection;
   DtNetFloat64                  myAmbientWaterTemperature;
   DtNetFloat64                  myTidalOffset;
   DtNetBoolean                  myTidalDirection;
   DtNetFloat64                  mySeaState;
   DtNetFloat64                  mySeaStateDirection;
   DtNetFloat64                  myWindDrivenSeaStateEnabled;
   DtNetU32                      mySwellState;
   DtNetFloat64                  mySwellStateDirection;
   DtNetFloat64                  myChoppiness;
   DtNetFloat64                  mySurgeDepth;
   DtNetFloat64                  myThermoclineLayer1Depth;
   DtNetFloat64                  myThermoclineLayer1Permeability;
   DtNetFloat64                  myThermoclineLayer2Depth;
   DtNetFloat64                  myThermoclineLayer2Permeability;
   DtNetFloat64                  myThermoclineLayer3Depth;
   DtNetFloat64                  myThermoclineLayer3Permeability;
   DtNetFloat64                  myThermoclineLayer4Depth;
   DtNetFloat64                  myThermoclineLayer4Permeability;
   DtNetFloat64                  myThermoclineLayer5Depth;
   DtNetFloat64                  myThermoclineLayer5Permeability;
   DtNetInt32                    myPriority;
};

struct DtNetWeatherStateRecord : public DtNetWeatherStateRecord_V4
{
   DtNetVector64                 myFogColor;
   DtNetFloat64                  myFogHeight;
   DtNetFloat64                  mySnowAccumulation;
   DtNetFloat64                  mySnowMinimumAltitude;
   DtNetFloat64                  mySnowRoadAccumulation;
   DtNetFloat64                  myRainAccumulation;
};

//
// Class Description: DtVrfEnvironmentalWeatherStateRecord
//
class DT_DLL_vrfExtObjects DtVrfEnvironmentalWeatherStateRecord :
   public DtEnvironmentalRecord
{
public:
   // Default Constructor.  To function properly, the state record should be
   // initialized with an entity type.  If you don't know it yet at creation
   // time, you can use this constructor; but call setEntityType() before
   // using the appearance accessors.
   DtVrfEnvironmentalWeatherStateRecord();

   DtVrfEnvironmentalWeatherStateRecord(
      const DtVrfEnvironmentalWeatherStateRecord& orig);

   // Assignment Operator
   const DtVrfEnvironmentalWeatherStateRecord& operator=(
      const DtVrfEnvironmentalWeatherStateRecord& orig);

   // Destructor
   virtual ~DtVrfEnvironmentalWeatherStateRecord();

   // Clone.  Return a copy of this instance.
   virtual DtEnvironmentalRecord* clone() const;

   // See #myAirTurbidity
   virtual void setAirTurbidity(double value);
   virtual double airTurbidity() const;

   // See #myPriority
   virtual void setPriority(int value);
   virtual int priority() const;

   // See #myAmbientAirTemperature
   virtual void setAmbientAirTemperature(double value);
   virtual double ambientAirTemperature() const;

   // See #myCloudState
    virtual void setCloudState(unsigned int value);
    virtual unsigned int cloudState() const;

   // See #myPrecipitationIntensity
   virtual void setPrecipitationIntensity(double value);
   virtual double precipitationIntensity() const;

   // See #myPrecipitationType
   virtual void setPrecipitationType(unsigned int value);
   virtual unsigned int precipitationType() const;

   // See #myWindSpeed
   virtual void setWindSpeed(double value);
   virtual double windSpeed() const;

   // See #myWindDirection
   virtual void setWindDirection(double value);
   virtual double windDirection() const;

   // See #myVisibility
   virtual void setVisibility(double value);
   virtual double visibility() const;

   // See #myIllumination
   virtual void setIllumination(double value);
   virtual double illumination() const;

   // Underwater visibility in meters
   virtual void setUnderwaterVisibility(double underwaterVisibility);
   virtual double underwaterVisibility();

   // Water surface transparency, a percentage represented by the range 0..1
   // with 1 being fully transparent.
   virtual void setSurfaceTransparency(double transparency);
   virtual double surfaceTransparency();

   // Water velocity in meters per second
   virtual void setWaterCurrentSpeed(double waterCurrentSpeed);
   virtual double waterCurrentSpeed();

   // Water direction in radians clockwise from 0 (north)
   virtual void setWaterCurrentDirection(double waterCurrentDirection);
   virtual double waterCurrentDirection();

   // Ambient water temperature in Celsius
   virtual void setAmbientWaterTemperature(double waterTemperature);
   virtual double ambientWaterTemperature();

   // Tidal offset in meters from the water polygons in the database
   virtual void setTidalOffset(double tidalOffset);
   virtual double tidalOffset();

   // Tidal direction where true represents the tide going in and false
   // represents the tide going out.
   virtual void setTidalDirection(bool tidalDirection);
   virtual bool tidalDirection();

   // Swell state according to the Douglas Sea Scale (integer 0 - 9)
   virtual void setSwellState(unsigned int state);
   virtual unsigned int swellState();

   // Swell direction in in radians clockwise from 0 (north)
   virtual void setSwellStateDirection(double direction);
   virtual double swellStateDirection();

   virtual void setSeaState(unsigned int douglasScale);
   virtual unsigned int seaState();

   virtual void setSeaStateDirection(double radiansFromNorth);
   virtual double seaStateDirection();

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

   // Wave choppiness (0..1)
   virtual void setChoppiness(double choppiness);
   virtual double choppiness();

   // Surge depth (meters)
   virtual void setSurgeDepth(double depth);
   virtual double surgeDepth();

   // Fog color
   virtual void setFogColor(double red, double green, double blue);
   virtual void getFogColor(double& red, double& green, double& blue);
   virtual DtVector fogColor();

   virtual void setFogHeight(double);
   virtual double fogHeight();

   virtual void setSnowAccumulation(double);
   virtual double snowAccumulation();

   virtual void setSnowMinimumAltitude(double);
   virtual double snowMinimumAltitude();

   virtual void setSnowRoadAccumulation(double);
   virtual double snowRoadAccumulation();

   virtual void setRainAccumulation(double);
   virtual double rainAccumulation();

   // Thermocline depth (in meters) and permeability (a percentage based on the
   // range 0..1 with 0 being impermeable and 1 being totally permeable). A
   // depth of zero means that layer is not used.
   virtual void setThermoclineLayer1Depth(double depth);
   virtual double thermoclineLayer1Depth();
   virtual void setThermoclineLayer1Permeability(double depth);
   virtual double thermoclineLayer1Permeability();
   virtual void setThermoclineLayer2Depth(double depth);
   virtual double thermoclineLayer2Depth();
   virtual void setThermoclineLayer2Permeability(double depth);
   virtual double thermoclineLayer2Permeability();
   virtual void setThermoclineLayer3Depth(double depth);
   virtual double thermoclineLayer3Depth();
   virtual void setThermoclineLayer3Permeability(double depth);
   virtual double thermoclineLayer3Permeability();
   virtual void setThermoclineLayer4Depth(double depth);
   virtual double thermoclineLayer4Depth();
   virtual void setThermoclineLayer4Permeability(double depth);
   virtual double thermoclineLayer4Permeability();
   virtual void setThermoclineLayer5Depth(double depth);
   virtual double thermoclineLayer5Depth();
   virtual void setThermoclineLayer5Permeability(double depth);
   virtual double thermoclineLayer5Permeability();

   // This doesn't need to be called explicitly.  If any routine that needs
   // the repository finds that it hasn't been created yet, it calls this
   // method.
   virtual bool createNetworkRepresentation();

   // returns the network representation of the environmental record
   const DtNetWeatherStateRecord* objStateNetRep() const;
   DtNetWeatherStateRecord* objStateNetRep();

   // used by the PDU class to fill in the network representation
   virtual void setFromNet(const DtNetEnvironmentalRecord& buffer, int protocolVersion);

   virtual int netRepSize() const;

   // The number of seconds past midnight.
   virtual double timeOfDay() const;

   // The number of seconds past 00:00 hours, Jan 1, 1970 UTC.  This routine will *also* set the time
   // of day by stripping off the day/month/year and leaving only time of day.  This MUST be set in UTC
   // else the time of day will be off based on time zones
   virtual time_t dateAndTimeOfDay() const;

   // The rate at which time of day is advancing, based on simulation time.
   // For example, 0 indicates that TOD is paused, 1 means it is advancing normally.
   virtual double timeOfDayAdvancementSpeed() const;

protected:

   virtual bool resizeNetRep(int newSize);

   // Reworks the network buffer based on version
   virtual void reworkStateRepForVersion(int bytesToCopy, int iVersion);

   // Casts the 'this' pointer for changing elements in a const function.
   DtVrfEnvironmentalWeatherStateRecord* self() const;

protected:
   int myNetRepSize;
   double myOldTimeOfDayAdvancementSpeed;
   time_t myOldTimeOfDay;
};