legacyRWData.h

Go to the documentation of this file.

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

#pragma once

#include "vrfobjcore/vrfobjcoreDefines.h"
#include <readerWriter/readerWriter.h>
#include <readerWriter/rwObjectType.h>
#include <readerWriter/rwInt.h>
#include <readerWriter/rwStringAttributeList.h>
#include <readerWriter/readerWriterRegistryData.h>
#include <readerWriter/rwProperties.h>
#include <vrfutil/rwUUID.h>
#include <vrfStateData/rwVrfKinematicState.h>
#include "vrfStateData/vrfObjectGeometry.h"
#include "vrfStateData/articulatedPartManager.h"
#include <vrfutil/rwDIGuyCharacterState.h>
#include <vrfutil/rwAggregateState.h>
#include <vrfutil/rwGaussianPuffData.h>
#include <vrfutil/rwAppearance.h>
#include <vrfutil/rwWindLevels.h>
#include <vrfobjparam/vrfObjectParameters.h>
#include <vrfExtObjects/vrfWeatherStateEnums.h>
#include "vrfutil/humidityTableUtils.h"

class DtVrfStateRepositoryUserExtension;

class DT_DLL_vrfobjcore DtScopedReaderWriter : public DtReaderWriter
{
public:

   DtScopedReaderWriter( const DtString& name, DtReaderWriterRegistry* parentRegistry )
      : DtReaderWriter( name, 0 )
      , myParentRegistry( parentRegistry )
   {
      std::vector<DtReaderWriterRegistryData*>::const_iterator iter = parentRegistry->registryData().begin();
      std::vector<DtReaderWriterRegistryData*>::const_iterator end = parentRegistry->registryData().end();

      while (iter != end)
      {
         myCurrentRegistryItems.insert((*iter)->readerWriter());
         ++iter;
      }
   }

   virtual ~DtScopedReaderWriter()
   {
      std::vector<DtReaderWriterRegistryData*> cpy(myParentRegistry->registryData());
      std::vector<DtReaderWriterRegistryData*>::const_iterator iter = cpy.begin();
      std::vector<DtReaderWriterRegistryData*>::const_iterator end = cpy.end();

      while (iter != end)
      {
         if (myCurrentRegistryItems.find((*iter)->readerWriter()) == myCurrentRegistryItems.end())
         {
            myParentRegistry->removeEntry((*iter)->readerWriter());
         }

         ++iter;
      }
   }

protected:
   std::set<DtReaderWriter*> myCurrentRegistryItems;
   DtReaderWriterRegistry* myParentRegistry;
};

class DT_DLL_vrfobjcore DtLegacySimObjectStateRepositoryRWData : public DtScopedReaderWriter
{
public:
   DtLegacySimObjectStateRepositoryRWData(const DtString& rwName, DtReaderWriterRegistry*  parentRegistry)
   : DtScopedReaderWriter(rwName, parentRegistry)
   , myKinematicState(0, "kinematics-state", parentRegistry)
   , myAttachedToRepositoryUUID("attached-to-repository", DtUUID::nullUUID(),parentRegistry)
   , myObjectGeometry("geometry", parentRegistry)
   , myObjectLabel("object-label", parentRegistry)
   , myOverlay("overlay-parent", parentRegistry)
   , myArticulatedParts(0, "articulated-parts", parentRegistry)
   {
      myAttachedToRepositoryUUID.setValueSpecified(false);
      myOverlay.addAlias("overlay");
   }

   virtual void initializeFromParameters(const DtVrfObjectParameters*) {};

   void setAttachedToRepository(const DtRwUUID& ot) { myAttachedToRepositoryUUID = ot; myAttachedToRepositoryUUID.setValueSpecified(ot.isValid()); };
   const DtRwUUID& attachedToRepository() const { return myAttachedToRepositoryUUID; };

   const makVrf::DtRwVrfKinematicState& kinematicState() const { return myKinematicState; };
   makVrf::DtRwVrfKinematicState& kinematicState() { return myKinematicState; };

   const makVrf::DtVrfObjectGeometry& objectGeometry() const { return myObjectGeometry; };
   makVrf::DtVrfObjectGeometry& objectGeometry() { return myObjectGeometry; };

   const makVrf::DtArticulatedPartManager& articulatedParts() const { return myArticulatedParts; };
   makVrf::DtArticulatedPartManager& articulatedParts() { return myArticulatedParts; };

   const DtString& objectLabel() const { return myObjectLabel; };
   void setObjectLabel(const DtString& l) { myObjectLabel = l; };

   const DtString& overlay() const { return myOverlay; };
   void setOverlay(const DtString& l) { myOverlay = l; };

   virtual void resolve() {};

private:
   DtLegacySimObjectStateRepositoryRWData(const DtLegacySimObjectStateRepositoryRWData& orig);

protected:
   DtRwUUID myAttachedToRepositoryUUID;
   makVrf::DtRwVrfKinematicState     myKinematicState;
   makVrf::DtVrfObjectGeometry     myObjectGeometry;
   DtRwString myObjectLabel;
   DtRwString myOverlay;
   makVrf::DtArticulatedPartManager myArticulatedParts;
};

class DT_DLL_vrfobjcore DtVrfObjectStateRepositoryRWData : public DtLegacySimObjectStateRepositoryRWData
{
public:
   DtVrfObjectStateRepositoryRWData(const DtString& rwName, DtReaderWriterRegistry*  parentRegistry)
   : DtLegacySimObjectStateRepositoryRWData(rwName, parentRegistry)
   , myForceType(DtForceOther, "force", parentRegistry)
   , myRwExtendedData("extended-data", parentRegistry)
   , myAppearance(DtEntityType(), "appearance", parentRegistry)
   , myStateProperties("state-data", parentRegistry)
   , myIndependentlyTasked("independently-tasked", parentRegistry)
   , myIsDestroyedFlag("is-destroyed", parentRegistry)
   , myCapabilities("capabilities", parentRegistry)
   , mySensorsKilled(false, "sensors-killed", parentRegistry)
   , myIsSubordinateOfForceLevel("subordinate-of-force-level", parentRegistry)
   , myExtendedLabels("extended-labels", parentRegistry)
   , myParent("parent-name", parentRegistry)
   , myDesignator("designator", parentRegistry)
   , myEngagementRules("engagement-rules", DtString::nullString(), parentRegistry)
   , myStationName("station-name", DtStationName::DtOnStation_XYZ, parentRegistry)
   {
   }

   virtual ~DtVrfObjectStateRepositoryRWData()
   {
   }

   void initializeFromParameters(const DtVrfObjectParameters* params)
   {
      myObjectGeometry.setBoundingGeometryType(
         params->boundingGeometryType());

      const Dt3dBoundingVolume* const bvPtr = params->boundingVolume();
      myObjectGeometry.setBoundingVolume(
         *bvPtr );

      myEngagementRules = params->engagementRules();

      myObjectGeometry.setValueSpecified(false);
      myEngagementRules.setValueSpecified(false);
   }

   DtRwProperties& stateProperties() { return myStateProperties; };
   const DtRwProperties& stateProperties() const { return myStateProperties; };

   DtRwStringAttributeList& rwExtendedData() { return myRwExtendedData; };
   const DtRwStringAttributeList& rwExtendedData() const { return myRwExtendedData; };

   DtRwIntegerAttributeList& rwExtendedLabels() { return myExtendedLabels; };
   const DtRwIntegerAttributeList& rwExtendedLabels() const { return myExtendedLabels; };

   void setIsDestroyed(bool b) { myIsDestroyedFlag = b; };
   bool isDestroyed() const { return myIsDestroyedFlag; };

   bool isSubordinateOfForceLevel() const { return myIsSubordinateOfForceLevel; };
   void setIsSubordinateOfForceLevel(bool b) { myIsSubordinateOfForceLevel = b; };

   bool independentlyTasked() const { return myIndependentlyTasked; };
   void setIndependentlyTasked(bool b) { myIndependentlyTasked = b; };

   const DtUUID& parent() const { return myParent; };
   void setParent(const DtUUID& p) { myParent = p; };

   void setAppearance(const DtAppearance& a) { myAppearance = a; };
   const DtAppearance& appearance() const { return myAppearance; };

   void setCapabilities(unsigned int c) { myCapabilities = c; };
   unsigned int capabilities() const { return myCapabilities.value(); };

   void setForceType(DtForceType c) { myForceType = c; };
   DtForceType forceType() const { return myForceType.value(); };

   void setDesignator(int i) { myDesignator = i; };
   int designator() const { return myDesignator; };

   void setEngagementRules(const DtString& s) { myEngagementRules = s; };
   const DtString& engagementRules() const { return myEngagementRules; };

   void setStationName(DtStationName name) { myStationName = name; };
   DtStationName stationName() const { return static_cast<DtStationName>(myStationName.value()); };

private:
   DtVrfObjectStateRepositoryRWData(const DtLegacySimObjectStateRepositoryRWData& orig);

protected:
   DtRwStringAttributeList  myRwExtendedData;
   DtRwAppearance           myAppearance;
   DtRwInt                  myCapabilities;
   DtRwForceType            myForceType;
   DtRwProperties           myStateProperties;
   DtRwBoolean              myIndependentlyTasked;
   DtRwBoolean              myIsDestroyedFlag;
   DtRwBoolean              mySensorsKilled;
   DtRwBoolean              myIsSubordinateOfForceLevel;
   DtRwIntegerAttributeList myExtendedLabels;
   DtRwUUID                 myParent;
   DtRwInt                  myDesignator;
   DtRwString               myEngagementRules;
   DtRwInt                  myStationName;
};

class DT_DLL_vrfobjcore DtVrfMovingObjectStateRepositoryRWData : public DtVrfObjectStateRepositoryRWData
{
public:
   DtVrfMovingObjectStateRepositoryRWData(const DtString& rwName, DtReaderWriterRegistry*  parentRegistry)
   : DtVrfObjectStateRepositoryRWData(rwName, parentRegistry)
   , myCharacterState("di-guy-character", parentRegistry)
   {
      myCharacterState.setValueSpecified(false);
   }

   DtRwDIGuyCharacterState& characterState() { return myCharacterState; };
   const DtRwDIGuyCharacterState& characterState() const { return myCharacterState; };

protected:
   DtRwDIGuyCharacterState myCharacterState;
};

class DT_DLL_vrfobjcore DtTacticalSmokeStateRepositoryRWData : public DtVrfObjectStateRepositoryRWData
{
public:
   DtTacticalSmokeStateRepositoryRWData(const DtString& rwName, DtReaderWriterRegistry*  parentRegistry)
   : DtVrfObjectStateRepositoryRWData(rwName, parentRegistry)
   , myPuffDataList("puff-list", parentRegistry)
   {
   }

   DtGaussianPuffDataList& puffDataList() { return myPuffDataList; };
   const DtGaussianPuffDataList& puffDataList() const { return myPuffDataList; };

protected:
   DtGaussianPuffDataList myPuffDataList;
};

class DT_DLL_vrfobjcore DtVrfOverlayObjectStateRepositoryRWData : public DtVrfObjectStateRepositoryRWData
{
public:
   DtVrfOverlayObjectStateRepositoryRWData(const DtString& rwName, DtReaderWriterRegistry*  parentRegistry)
   : DtVrfObjectStateRepositoryRWData(rwName, parentRegistry)
   , myColor ("overlay-color", 0, parentRegistry)
   , myUserData("user-data", "", parentRegistry)
   , myPhysicalLineHeight("physical-line-height", 0., parentRegistry)
   , myPhysicalLineWidth("physical-line-width", 0., parentRegistry)
   {
   }

   virtual ~DtVrfOverlayObjectStateRepositoryRWData()
   {
   }

   void setPhysicalLineHeight(double d) { myPhysicalLineHeight = d; myPhysicalLineHeight.setValueSpecified(d != 0.); };
   double physicalLineHeight() const { return myPhysicalLineHeight; };

   void setPhysicalLineWidth(double d) { myPhysicalLineWidth = d; myPhysicalLineWidth.setValueSpecified(d != 0.); };
   double physicalLineWidth() const { return myPhysicalLineWidth; };

   void setUserData(const DtString& s) { myUserData = s; myUserData.setValueSpecified(s.length() != 0); };
   const DtString& userData() const { return myUserData; };

   void setColor(int c) { myColor = c; };
   int color() const { return myColor; };

protected:
   DtRwInt myColor;

   DtRwReal    myPhysicalLineHeight;
   DtRwReal    myPhysicalLineWidth;

   DtRwString  myUserData;
};


class DT_DLL_vrfobjcore DtCloudStateRepositoryRWData : public DtVrfOverlayObjectStateRepositoryRWData
{
public:
   DtCloudStateRepositoryRWData(const DtString& rwName, DtReaderWriterRegistry*  parentRegistry)
   : DtVrfOverlayObjectStateRepositoryRWData(rwName, parentRegistry)
   , myCloudType("cloud-type", parentRegistry)
   , myCloudAltitude("cloud-altitude", parentRegistry)
   , myCloudThickness("cloud-thickness", parentRegistry)
   , myCornerRadius("corner-radius", parentRegistry)
   , myCloudDensity("cloud-density", parentRegistry)
   , myLightningPresent("lightning-present", parentRegistry)
   {
      myLightningPresent = false;
   }

   virtual ~DtCloudStateRepositoryRWData()
   {
   }


   void setCloudType(int value) { myCloudType = value; };
   int cloudType() const { return myCloudType; };


   void setCloudAltitude(double value) { myCloudAltitude = value; };
   double cloudAltitude() const { return myCloudAltitude; };


   void setCloudThickness(double value) { myCloudThickness = value; };
   double cloudThickness() const { return myCloudThickness; };


   void setCornerRadius(double value) { myCornerRadius = value; };
   double cornerRadius() const { return myCornerRadius; };


   void setCloudDensity(double value) { myCloudDensity = value; };
   double cloudDensity() const { return myCloudDensity; };

   virtual void setLightningPresent(bool isPresent) { myLightningPresent = isPresent; };
   virtual bool lightningPresent() const { return myLightningPresent; };

protected:



   DtRwInt  myCloudType;

   DtRwReal myCloudAltitude;

   DtRwReal myCloudThickness;

   DtRwReal myCornerRadius;

   DtRwReal myCloudDensity;

   DtRwBoolean myLightningPresent;
};

class DT_DLL_vrfobjcore DtWeatherStateRepositoryRWData : public DtVrfOverlayObjectStateRepositoryRWData
{
public:
   DtWeatherStateRepositoryRWData(const DtString& rwName, DtReaderWriterRegistry*  parentRegistry)
   : DtVrfOverlayObjectStateRepositoryRWData(rwName, parentRegistry)
   , myAirTurbidity("air-turbidity", parentRegistry)
   , myAmbientAirTemperature("ambient-air-temperature", parentRegistry)
   , myAmbientAirPressure("ambient-air-pressure", parentRegistry)
   , myAirTemperatureAltitude("air-temperature-altitude", parentRegistry)
   , myAirPressureAltitude("air-pressure-altitude", parentRegistry)
   , myAirTemperatureAltitudeIsSeaLevel("air-temperature-altitude-is-sea-level", parentRegistry)
   , myAirPressureAltitudeIsSeaLevel("air-pressure-altitude-is-sea-level", parentRegistry)
   , mySeaLevelWaterConcentration("sea-level-water-concentration", parentRegistry)
   , myCloudState("cloud-state", parentRegistry)
   , myPrecipitationIntensity("precipitation-intensity", parentRegistry)
   , myPrecipitationType("precipitation-type", parentRegistry)
   , myVisibility("visibility", parentRegistry)
   , myWindDirection("wind-direction", parentRegistry)
   , myWindSpeed("wind-speed", parentRegistry)
   , myPriority("priority",parentRegistry)
   , myUnderwaterVisibility("underwater-visibility", parentRegistry)
   , mySurfaceTransparency("surface-transparency", parentRegistry)
   , myWaterCurrentSpeed("water-current-speed", parentRegistry)
   , myWaterCurrentDirection("water-current-direction", parentRegistry)
   , myAmbientWaterTemperature("ambient-water-temperature", parentRegistry)
   , myTidalOffset("tidal-offset", parentRegistry)
   , myTidalDirection("tidal-direction", parentRegistry)
   , mySwellState("swell-state", parentRegistry)
   , mySwellStateDirection("swell-state-direction", parentRegistry)
   , mySeaState("sea-state", parentRegistry)
   , mySeaStateDirection("sea-state-direction", parentRegistry)
   , myWindDrivenSeaStateEnabled("wind-driven-sea-state-enabled", parentRegistry)
   , myChoppiness("choppiness", parentRegistry)
   , mySurgeDepth("surge-depth", parentRegistry)
   , myFogHeight("fog-height", parentRegistry)
   , myFogColor("fog-color", parentRegistry)
   , mySnowAccumulation("snow-accumulation", parentRegistry)
   , myRainAccumulation("rain-accumulation", parentRegistry)
   , mySnowMinimumAltitude("snow-minimum-altitude", parentRegistry)
   , mySnowRoadAccumulation("snow-road-accumulation", parentRegistry)
   , myThermoclineLayer1Depth("thermocline-layer1-depth", parentRegistry)
   , myThermoclineLayer1Permeability("thermocline-layer1-permeability", parentRegistry)
   , myThermoclineLayer2Depth("thermocline-layer2-depth", parentRegistry)
   , myThermoclineLayer2Permeability("thermocline-layer2-permeability", parentRegistry)
   , myThermoclineLayer3Depth("thermocline-layer3-depth", parentRegistry)
   , myThermoclineLayer3Permeability("thermocline-layer3-permeability", parentRegistry)
   , myThermoclineLayer4Depth("thermocline-layer4-depth", parentRegistry)
   , myThermoclineLayer4Permeability("thermocline-layer4-permeability", parentRegistry)
   , myThermoclineLayer5Depth("thermocline-layer5-depth", parentRegistry)
   , myThermoclineLayer5Permeability("thermocline-layer5-permeability", parentRegistry)
   , myWindLevels("wind-levels", parentRegistry)
   , myLightningPresent("lightning-present", parentRegistry)
   {
      myLightningPresent = false;
      myAirTurbidity = 0.0;
      myAmbientAirTemperature = 15.000;
      myAirTemperatureAltitude = 0.0; 
      myAirPressureAltitude = 0.0; 
      myAirTemperatureAltitudeIsSeaLevel = true;
      myAirPressureAltitudeIsSeaLevel = true;
      mySeaLevelWaterConcentration = makVrf::DtHumidityTableUtils::instance()->humidityAtSeaLevel();
      myAmbientAirTemperature = 1000.00;
      myCloudState = DtVrfWeatherCloudStatePartlyCloudy;
      myPrecipitationIntensity = 0.25;
      myPrecipitationType = DtVrfWeatherPrecipitationNone;
      myVisibility = 30000.0;
      myWindDirection = 0;
      myWindSpeed = 2.77778;
      myPriority = 0;
      myUnderwaterVisibility = 450.0;
      mySurfaceTransparency = 0.039999999;
      myWaterCurrentSpeed = 0;
      myWaterCurrentDirection = 0;
      myAmbientWaterTemperature = 20.0;
      myTidalOffset = 0;
      myTidalDirection = false;
      mySwellState = 0;
      mySwellStateDirection = 0;
      mySeaState = 3;
      mySeaStateDirection = 0;
      myWindDrivenSeaStateEnabled = true;
      myChoppiness = 0.66000003;
      mySurgeDepth = 8.0;
      myFogHeight = 0.0;
      myThermoclineLayer1Depth = 0;
      myThermoclineLayer1Permeability = 0;
      myThermoclineLayer2Depth = 0;
      myThermoclineLayer2Permeability = 0;
      myThermoclineLayer3Depth = 0;
      myThermoclineLayer3Permeability = 0;
      myThermoclineLayer4Depth = 0;
      myThermoclineLayer4Permeability = 0;
      myThermoclineLayer5Depth = 0;
      myThermoclineLayer5Permeability = 0;
      myFogHeight = 250.0;
      myFogColor = DtVector(0.56078434,0.73725492,0.90588236);
      myRainAccumulation = 0;
      mySnowAccumulation = 0;
      mySnowMinimumAltitude = 0;
      mySnowRoadAccumulation = 0;
      myWindSpeed.setValueSpecified(false);
      myWindDirection.setValueSpecified(false);
      myVisibility.setValueSpecified(false);
   }

   virtual ~DtWeatherStateRepositoryRWData()
   {
   }


   void setAirTurbidity(double value) { myAirTurbidity = value; };
   double airTurbidity() const { return myAirTurbidity; };


   void setAmbientAirTemperature(double value) { myAmbientAirTemperature = value; };
   double ambientAirTemperature() const { return myAmbientAirTemperature; };


   void setAmbientAirPressure(double value) { myAmbientAirPressure = value; };
   double ambientAirPressure() const { return myAmbientAirPressure; };


   void setCloudState(DtVrfWeatherCloudState current) { myCloudState = current; };
   DtVrfWeatherCloudState cloudState() const { return (DtVrfWeatherCloudState)myCloudState.value(); };

   //{@
   virtual void setLightningPresent(bool isPresent) { myLightningPresent = isPresent; };
   virtual bool lightningPresent() const { return myLightningPresent; };



   void setPrecipitationIntensity(double value) { myPrecipitationIntensity = value; };
   double precipitationIntensity() const { return myPrecipitationIntensity; };


   void setPrecipitationType(DtVrfWeatherPrecipitationType value) { myPrecipitationType = value; };
   DtVrfWeatherPrecipitationType precipitationType() const { return (DtVrfWeatherPrecipitationType)myPrecipitationType.value(); };


   void setPriority(int value) { myPriority = value; };
   int priority() const { return myPriority; };


   void setUnderwaterVisibility(double value) { myUnderwaterVisibility = value; };
   double underwaterVisibility() const { return myUnderwaterVisibility; };


   void setSurfaceTransparency(double value) { mySurfaceTransparency = value; };
   double surfaceTransparency() const { return mySurfaceTransparency; };


   void setWaterCurrentSpeed(double value) { myWaterCurrentSpeed = value; };
   double waterCurrentSpeed() const { return myWaterCurrentSpeed; };


   void setWaterCurrentDirection(double value) { myWaterCurrentDirection = value; };
   double waterCurrentDirection() const { return myWaterCurrentDirection; };


   void setAmbientWaterTemperature(double value) { myAmbientWaterTemperature = value; };
   double ambientWaterTemperature() const { return myAmbientWaterTemperature; };


   void setTidalOffset(double value) { myTidalOffset = value; };
   double tidalOffset() const { return myTidalOffset; };


   void setTidalDirection(bool value) { myTidalDirection = value; };
   bool tidalDirection() const { return myTidalDirection; };


   void setSwellState(unsigned int value) { mySwellState = value; };
   unsigned int swellState() const { return mySwellState; };


   void setSwellStateDirection(double value) { mySwellStateDirection = value; };
   double swellStateDirection() const { return mySwellStateDirection; };


   void setSeaState(unsigned int value) { mySeaState = value; };
   unsigned int seaState() const { return mySeaState; };


   void setSeaStateDirection(double value) { mySeaStateDirection = value; };
   double seaStateDirection() const { return mySeaStateDirection; };


   void setWindDrivenSeaStateEnabled(bool b) { myWindDrivenSeaStateEnabled = b; };
   bool windDrivenSeaStateEnabled() const { return myWindDrivenSeaStateEnabled; };


   void setChoppiness(double value) { myChoppiness = value; };
   double choppiness() const { return myChoppiness; };


   void setSurgeDepth(double value) { mySurgeDepth = value; };
   double surgeDepth() const { return mySurgeDepth; };


   void setFogHeight(double value) { myFogHeight = value; };
   double fogHeight() const { return myFogHeight; };


   void setFogColor(const DtVector& color) { myFogColor = color; };
   const DtVector& fogColor() const { return myFogColor; };


   virtual void setSnowAccumulation(double snow) { mySnowAccumulation = snow; };
   virtual double snowAccumulation() const { return mySnowAccumulation; };


   virtual void setRainAccumulation(double snow) { myRainAccumulation = snow; };
   virtual double rainAccumulation() const { return myRainAccumulation; };


   virtual void setSnowMinimumAltitude(double snow) { mySnowMinimumAltitude = snow; };
   virtual double snowMinimumAltitude() const { return mySnowMinimumAltitude; };


   virtual void setSnowRoadAccumulation(double snow) { mySnowRoadAccumulation = snow; };
   virtual double snowRoadAccumulation() const { return mySnowRoadAccumulation; };


   virtual void setAirTemperatureAltitude(double value) { myAirTemperatureAltitude = value; };
   virtual double airTemperatureAltitude() const { return myAirTemperatureAltitude; };


   virtual void setAirPressureAltitude(double value) { myAirPressureAltitude = value; };
   virtual double airPressureAltitude() const { return myAirPressureAltitude; };


   virtual void setAirTemperatureAltitudeIsSeaLevel(bool value) { myAirTemperatureAltitudeIsSeaLevel = value; };
   virtual bool airTemperatureAltitudeIsSeaLevel() const { return myAirTemperatureAltitudeIsSeaLevel; };


   virtual void setAirPressureAltitudeIsSeaLevel(bool value) { myAirPressureAltitudeIsSeaLevel = value; };
   virtual bool airPressureAltitudeIsSeaLevel() const { return myAirPressureAltitudeIsSeaLevel; };


   virtual void setSeaLevelWaterConcentration(double value) { mySeaLevelWaterConcentration = value; };
   virtual double seaLevelWaterConcentration() const { return mySeaLevelWaterConcentration; };


   void setThermoclineLayer1Depth(double depth) { myThermoclineLayer1Depth = depth; };
   double thermoclineLayer1Depth() const { return myThermoclineLayer1Depth; };
   void setThermoclineLayer1Permeability(double depth) { myThermoclineLayer1Permeability = depth; };
   double thermoclineLayer1Permeability() const { return myThermoclineLayer1Permeability; };
   void setThermoclineLayer2Depth(double depth) { myThermoclineLayer2Depth = depth; };
   double thermoclineLayer2Depth() const { return myThermoclineLayer2Depth; };
   void setThermoclineLayer2Permeability(double depth) { myThermoclineLayer2Permeability = depth; };
   double thermoclineLayer2Permeability() const { return myThermoclineLayer2Permeability; };
   void setThermoclineLayer3Depth(double depth) { myThermoclineLayer3Depth = depth; };
   double thermoclineLayer3Depth() const { return myThermoclineLayer3Depth; };
   void setThermoclineLayer3Permeability(double depth) { myThermoclineLayer3Permeability = depth; };
   double thermoclineLayer3Permeability() const { return myThermoclineLayer3Permeability; };
   void setThermoclineLayer4Depth(double depth) { myThermoclineLayer4Depth = depth; };
   double thermoclineLayer4Depth() const { return myThermoclineLayer4Depth; };
   void setThermoclineLayer4Permeability(double depth) { myThermoclineLayer4Permeability = depth; };
   double thermoclineLayer4Permeability() const { return myThermoclineLayer4Permeability; };
   void setThermoclineLayer5Depth(double depth) { myThermoclineLayer5Depth = depth; };
   double thermoclineLayer5Depth() const { return myThermoclineLayer5Depth; };
   void setThermoclineLayer5Permeability(double depth) { myThermoclineLayer5Permeability = depth; };
   double thermoclineLayer5Permeability() const { return myThermoclineLayer5Permeability; };

   const DtRwWindLevels& windLevels() const { return myWindLevels; };
   DtRwWindLevels& windLevels() { return myWindLevels; };

   void resolve() override
   {
      DtVrfOverlayObjectStateRepositoryRWData::resolve();

      if (myWindSpeed.valueSpecified() || myWindDirection.valueSpecified())
      {
         double speed;
         double dir;

         myWindLevels.windSpeedAndDirectionAtAltitude(0., speed, dir);

         if (myWindSpeed.valueSpecified())
         {
            speed = myWindSpeed;
         }

         if (myWindDirection.valueSpecified())
         {
            dir = myWindDirection;
         }

         myWindLevels.setWindSpeedAndDirectionAtAltitude(0., speed, dir);
      }

      if (myVisibility.valueSpecified())
      {
         double vis;
         int obs;

         myWindLevels.visibilityAndObscurantAtAltitude(0., vis, obs);
         vis = myVisibility;

         myWindLevels.setVisibilityAndObscurantAtAltitude(0., vis, 1);
      }
   }

protected:



   DtRwReal          myAirTurbidity;

   DtRwReal          myAmbientAirTemperature;

   DtRwReal          myAirTemperatureAltitude;

   DtRwReal          myAirPressureAltitude;

   DtRwBoolean          myAirTemperatureAltitudeIsSeaLevel;

   DtRwBoolean          myAirPressureAltitudeIsSeaLevel;

   DtRwReal          mySeaLevelWaterConcentration;

   DtRwReal          myAmbientAirPressure;

   DtRwInt myCloudState;

   DtRwReal          myPrecipitationIntensity;

   DtRwInt           myPrecipitationType;

   DtRwReal          myWindSpeed;

   DtRwReal          myWindDirection;

   DtRwInt            myPriority;

   DtRwReal myVisibility;

   DtRwReal myUnderwaterVisibility;

   DtRwReal mySurfaceTransparency;

   DtRwReal myWaterCurrentSpeed;

   DtRwReal myWaterCurrentDirection;

   DtRwReal myAmbientWaterTemperature;

   DtRwReal myTidalOffset;

   DtRwBoolean myTidalDirection;

   DtRwInt  mySwellState;

   DtRwReal mySwellStateDirection;

   DtRwInt  mySeaState;

   DtRwReal mySeaStateDirection;

   DtRwBoolean myWindDrivenSeaStateEnabled;

   DtRwReal myChoppiness;

   DtRwReal mySurgeDepth;

   DtRwReal myFogHeight;

   DtRwVector myFogColor;

   DtRwReal mySnowAccumulation;

   DtRwReal myRainAccumulation;

   DtRwReal mySnowMinimumAltitude;

   DtRwReal mySnowRoadAccumulation;

   DtRwReal myThermoclineLayer1Depth;

   DtRwReal myThermoclineLayer1Permeability;

   DtRwReal myThermoclineLayer2Depth;
   DtRwReal myThermoclineLayer2Permeability;

   DtRwReal myThermoclineLayer3Depth;
   DtRwReal myThermoclineLayer3Permeability;

   DtRwReal myThermoclineLayer4Depth;
   DtRwReal myThermoclineLayer4Permeability;

   DtRwReal myThermoclineLayer5Depth;
   DtRwReal myThermoclineLayer5Permeability;

   DtRwBoolean myLightningPresent;

   DtRwWindLevels myWindLevels;
};

class DT_DLL_vrfobjcore DtGlobalEnvironmentStateRepositoryRWData : public DtWeatherStateRepositoryRWData
{
public:
   DtGlobalEnvironmentStateRepositoryRWData(const DtString& rwName, DtReaderWriterRegistry*  parentRegistry)
      : DtWeatherStateRepositoryRWData(rwName, parentRegistry)
      , myTimeOfDay("time-of-day",parentRegistry)
      , myTimeOfDayAdvancementSpeed("time-of-day-advancement-speed",parentRegistry)
      , myUseDayNightIlluminationModel("use-day-night-illumination-model", parentRegistry)
      , mySetScenarioStartTimeAtLocalOnFirstObjectCreationToTime("set-scenario-start-time-at-local-on-first-object-creation-time", parentRegistry)
      , myStartTimeIsLocal("start-time-is-local", parentRegistry)
   {
      myTimeOfDay.setValueSpecified(false);
      myStartTimeIsLocal = true;
   }

   void setDateAndTimeOfDay(double d) { myTimeOfDay = d; myTimeOfDay.setValueSpecified(true); };
   double dateAndTimeOfDay() const { return myTimeOfDay; };
   bool dateAndTimeOfDaySpecified() const { return myTimeOfDay.valueSpecified(); };

   void setTimeOfDayAdvancementSpeed(double d) { myTimeOfDayAdvancementSpeed = d; };
   double timeOfDayAdvancementSpeed() const { return myTimeOfDayAdvancementSpeed; };

   void setUseDayNightIlluminationModel(bool b) { myUseDayNightIlluminationModel  = b; };
   bool useDayNightIlluminationModel() const { return myUseDayNightIlluminationModel; };

   void setStartTimeIsLocal(bool b) { myStartTimeIsLocal  = b; myStartTimeIsLocal.setValueSpecified(b); };
   bool startTimeIsLocal() const { return myStartTimeIsLocal; };

   void setScenarioStartTimeAtLocalOnFirstObjectCreationToTime(int i) { mySetScenarioStartTimeAtLocalOnFirstObjectCreationToTime = i; };
   int scenarioStartTimeAtLocalOnFirstObjectCreationToTime() const { return mySetScenarioStartTimeAtLocalOnFirstObjectCreationToTime; };

protected:

   DtRwReal            myTimeOfDay;

   DtRwReal            myTimeOfDayAdvancementSpeed;

   DtRwBoolean         myUseDayNightIlluminationModel;

   DtRwInt mySetScenarioStartTimeAtLocalOnFirstObjectCreationToTime;

   DtRwBoolean myStartTimeIsLocal;
};

class DT_DLL_vrfobjcore DtVrfAggregateStateRepositoryRWData : public DtVrfMovingObjectStateRepositoryRWData
{
public:
   DtVrfAggregateStateRepositoryRWData(const DtString& rwName, DtReaderWriterRegistry*  parentRegistry)
   : DtVrfMovingObjectStateRepositoryRWData(rwName, parentRegistry)
   , myFormation("formation", parentRegistry)
   , myFormationName("formation-name", parentRegistry)
   , myAggregateState("aggregate-state", parentRegistry)
   , myBlockSetFormationChange("block-set-formation-change", parentRegistry)
   {
   }

   void setFormation(DtAggregateFormation f) { myFormation = f; };
   DtAggregateFormation formation() const { return myFormation; };

   void setFormationName(const DtString& s) { myFormationName = s;};
   const DtString& formationName() const { return myFormationName; };

   void setAggregateState(DtAggregateState s) { myAggregateState = s; };
   DtAggregateState aggregateState() const { return myAggregateState; };

   void setBlockSetFormationChange(bool b) { myBlockSetFormationChange = b; myBlockSetFormationChange.setValueSpecified(b); myBlockSetFormationChange.setReadonly(!b); };
   bool blockSetFormationChange() const { return myBlockSetFormationChange; };

protected:
   DtRwFormationType myFormation;
   DtRwString myFormationName;
   DtRwAggregateState myAggregateState;
   DtRwBoolean myBlockSetFormationChange;
};