DtLocalEnvironmentalsControllerObject.h

Go to the documentation of this file.

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


#pragma once

#include <makArchives/DtCloudCoverType.h>

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtCloudLayer.h>
#include <vrvCore/DtUniqueID.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <matrix/vlVector.h>

namespace makVrv
{
   class DtCoordinateConverter;

   class DT_DLL_VRVCORE DtLocalEnvironmentalsControllerObject
   {
   public:

      DtLocalEnvironmentalsControllerObject(DtDe& de, DtUniqueID id);

      virtual ~DtLocalEnvironmentalsControllerObject();

      DtLocalEnvironmentalsControllerObject() = delete;

      DtLocalEnvironmentalsControllerObject(const DtLocalEnvironmentalsControllerObject &) = delete;

      DtLocalEnvironmentalsControllerObject &operator=(const DtLocalEnvironmentalsControllerObject &) = delete;

      virtual DtCloudLayerId addLayerToCloudCover(const DtCloudLayer& layer, const std::string& coverName);

      virtual void setZoneOrigin(double x, double y, double z);

      virtual void setZoneShape(double width, double length, double height, double cornerRadius);

      virtual void setAirTurbidity(float turbidity);

      virtual void setAmbientAirTemperature(float temperature);

      virtual void setAmbientAirPressure(float pressure);

      virtual void setAirTemperatureAltitude(float altitude);

      virtual void setAirPressureAltitude(float altitude);

      virtual void setAirTemperatureAltitudeIsSeaLevel(bool seaLevel);

      virtual void setAirPressureAltitudeIsSeaLevel(bool seaLevel);

      virtual void setSeaLevelWaterConcentration(float water);

      virtual void setLightningPresent(bool lightningPresent);

      virtual void setBlowingParticulateMatter(unsigned int type);

      virtual void setPrecipitationType(unsigned int type);

      virtual void setPrecipitationIntensity(float intensity);

      virtual void setTimeOfDay(int hour, int minutes, double seconds);

      virtual void setDateAndTimeOfDay(int year, int month, int day,
         int hour, int minutes, double seconds);

      virtual void setUseGlobalTimeZone(bool value);

      virtual void setTimeOfDayAdvancementSpeed(float speed);

      virtual void setFogHeight(float value);

      virtual void setFogColor(const DtVector& color);

      virtual void setFogColor(float red, float green, float blue);

      virtual void setFogColor(int red, int green, int blue);

      virtual void removeElevationalConfiguration(float baseMSLAltitude);

      virtual void updateOrAddElevationalConfiguration(float baseMSLAltitude,
         float windSpeed, float windDirection,
         float visibilityDistance, unsigned int obscurant,
         int cloudType, float cloudDensity, float skyCoverage);

      virtual void setSwellState(int state);

      virtual void setSwellStateDirection(float value);

      virtual void setSeaState(int state);

      virtual void setSeaStateDirection(float value);

      virtual void setWindDrivenSeaStateEnabled(bool value);

      virtual void setWindFetch(float value);

      virtual void setSeaChoppiness(float value);

      virtual void setUnderwaterVisibility(float distance);

      virtual void setSurfaceTransparency(float value);

      virtual void setSurgeDepth(float value);

      virtual void setAmbientWaterTemperature(float temperature);

      virtual void setWaterCurrentSpeed(float speed);

      virtual void setWaterCurrentDirection(float direction);

      virtual void setTidalOffset(float meters);

      virtual void setTidalDirection(bool inOut);

      virtual void setThermoclineDepth(unsigned int layer, float value);

      virtual void setThermoclinePermeability(unsigned int layer, float value);

      virtual void setGroundSnowAccumulation(float depth);

      virtual void setRoadSnowAccumulation(float depth);

      virtual void setSnowMinimumElevation(float elevation);

      virtual void setSnowElevationTransition(float elevation);

      virtual void setGroundRainAccumulation(float depth);

   protected:

      virtual bool ensureWeatherAreaCreated();

      virtual void computeOriginBasis(DtVector& origin, DtVector& north, DtVector& east, DtVector& up);

      virtual int mapBlowingParticulateMatterToCloudType(unsigned int type) const;

      virtual void updateOrAddCloudForElevation(float baseMSLAltitude,
         int cloudType, float cloudDensity, float skyCoverage,
         float visibilityDistance);

      virtual bool hasCloud(float baseMSLAltitude, int cloudType, float cloudDensity,
         float skyCoverage, float visibilityDistance) const;

      virtual void removeAllCloudsAtElevation(float baseMSLAltitude);

      virtual void refreshCloudLayerThicknessIfNeeded();

      virtual void adjustWeatherAreaForClouds();

      virtual const float computeDensityFromVisibility(const float visibility) const;

      virtual const float computeCloudThickness(const float baseMSLAltitude) const;

      virtual void slot_coordinateSystemChanged();

   protected:

      DtDe& myDe;

      DtVector myOrigin;
      double myWidth;
      double myLength;
      double myHeight;
      double myCornerRadius;

      struct CloudLayerData
      {
         CloudLayerData() : layerId(DtCloudLayerIdUndefined)
            , localPosition(0, 0, 0)
            , baseMSLAltitude(0)
            , cloudType(0)
            , cloudDensity(0)
            , skyCoverage(0)
            , visibilityDistance(0)
            , boundsScale(1)
         {
            // intentional noop
         }

         DtCloudLayerId layerId;
         DtCloudLayer cloudLayer;
         DtVector localPosition;
         float baseMSLAltitude;
         int cloudType;
         float cloudDensity;
         float skyCoverage;
         float visibilityDistance;
         float boundsScale;
      };

      struct CloudLayerSortComparator
      {
      public:
         bool operator()(
            const DtLocalEnvironmentalsControllerObject::CloudLayerData* lhs,
            const DtLocalEnvironmentalsControllerObject::CloudLayerData* rhs);
      };

      typedef std::vector<CloudLayerData*> CloudLayerSet;

      CloudLayerSet myCloudLayerSet;

      unsigned int myPrecipitationType;
      float myPrecipitationIntensity;

      float myGroundRainAccumulation;

      DtVector myFogColor;
      float myVisibilityDistance;
      float myOvercast;
      float myWindDirection;
      float myWindSpeed;

      bool myLightningEnabled;
      unsigned int myBlowingParticulateMatter;

      DtUniqueID myWeatherAreaId;

      DtSignalConnectionManager myConnections;

      DtCoordinateConverter* myCoordinateConverter = nullptr;
   };
}