DtSkyObject.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtCloudCoverManager.h>

#include <vrvCore/DtUniqueID.h>

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/signalslib.h>

#include <matrix/vlVector.h>

namespace makVrv
{
   class DtDe;
   class DtSkyObjectSignaler;

   class DT_DLL_VRVCORE DtSkyObject
   {
      //We should refactor the class with the DtDynamicOceanObject and DtWeatherEffectObject
      // and combine them to make a consistent way 
      // to send down environment settings to the RDE.
   public:

      class CloudLayer
      {
      public:
         CloudLayer(DtCloudLayerId layerId = DtCloudLayerIdUndefined, int type = 0,
            const DtVector& location = DtVector(0, 0, 0), float orientation = 0., float cornerRadius = 0.,
            const DtVector& bounds = DtVector(0, 0, 0), double density = 0.0, bool infinite = false,
            bool relative = false,
            bool fadeAtAltitude = true, bool altitudeIsHAT = true)
            : myLayerId(layerId)
            , myType(type)
            , myLocation(location)
            , myOrientation(orientation)
            , myCornerRadius(cornerRadius)
            , myBounds(bounds)
            , myDensity(density)
            , myInfinite(infinite)
            , myRelative(relative)
            , myEnabled(false)
            , myFadeAtAltitude(fadeAtAltitude)
            , myAltitudeIsHAT(altitudeIsHAT)
         {}

      public:
         DtCloudLayerId myLayerId;
         int myType;
         DtVector myLocation;
         float myOrientation;
         float myCornerRadius;
         DtVector myBounds;
         double myDensity;
         bool myInfinite;
         bool myRelative;
         bool myEnabled;
         bool myFadeAtAltitude;
         bool myAltitudeIsHAT;
      };

      enum PrecipitationType
      {
         None = 0,
         Rain = 1,
         SnowWet = 2,
         SnowDry = 3,
         Sleet = 4,
         Hail = 5,
         Drizzle = 6,
      };

      const static float theDefaultDayLightLevel;
      const static float theDefaultSkyShadowsLightLevelNoHdr;
      const static float theDefaultSkyShadowsLightLevelHdr;
      const static float theDefaultFogVisibilityLevel; 
      const static double theMaximumPrecipitationRate;
      const static float theMaximumVisibilityDistance;

      DtSkyObject(DtDe& de, DtUniqueID id);

      virtual ~DtSkyObject();

      virtual void setLocation( const DtVector& location );

      virtual void setDateAndTime(unsigned short year, unsigned char month,
         unsigned char day, unsigned char hour, unsigned char minutes,
         double seconds, bool observeDaylightSavings);

      // XXX New methods to document
      virtual void addCloudLayer(DtCloudLayerId layerId) = 0;
      virtual void sendCloudLayer(DtCloudLayerId layerId) = 0;
      virtual void setCloudLayerDeckType(DtCloudLayerId layerId, int deckType) = 0;
      virtual void setCloudLayerCornerRadius(DtCloudLayerId layerId, float corner) = 0;
      virtual void setCloudLayerBounds(DtCloudLayerId layerId, const DtVector& bounds) = 0;
      virtual void setCloudLayerDensity(DtCloudLayerId layerId, double density) = 0;
      virtual void setCloudLayerInfiniteFlag(DtCloudLayerId layerId, bool infinite) = 0;
      virtual void setCloudLayerRelativeFlag(DtCloudLayerId layerId, bool relative) = 0;
      virtual void setCloudLayerFadeAtAltitudeFlag(DtCloudLayerId layerId, bool fadeAtAltitude) = 0;
      virtual void setCloudLayerAltitudeIsHATFlag(DtCloudLayerId layerId, bool altitudeIsHAT) = 0;
      virtual CloudLayer* findCloudLayer(DtCloudLayerId layerId) = 0;

      virtual void setCloudLayerEnabled(DtCloudLayerId layerId, bool enabled) = 0;

      //virtual int cloudLayerCount() const;     

      virtual void removeCloudLayer(DtCloudLayerId layerId) = 0;

      virtual void removeCloudLayers() = 0;

      virtual void setAirTurbidity(float turbidity) = 0;

      virtual void setAmbientAirTemperature(float temperature) = 0;

      virtual void setVisibleDistance(float distance) = 0;

      virtual void setPrecipitationEnabled(bool enabled) = 0;

      virtual void setPrecipitationType(int type) = 0;

      virtual void setPrecipitationIntensity(float intensity) = 0;

      virtual void setCloudLayerPositionAndOrientation(DtCloudLayerId layerId, const DtVector&position, 
         float orientation) = 0;

      virtual void setFogHeight(float meters) = 0;

      virtual void setFogColor(const DtVector& color) = 0;

      virtual void setGroundFogColor(const DtVector& color) = 0;

      virtual void setWindSpeed(float metersPerSecond) = 0;

      virtual void setWindDirection(float radians) = 0;

      //@(
      void setAmbientLightValue( float ambientLightValue );
      float ambientLightValue() const;

      //@(
      bool isDaylight() const;

      bool isSkyCastingShadows() const;

   protected:

      float myAmbientLightValue;
      DtSkyObjectSignaler& mySignaler;
      DtDe& myDe;
   };

   class DT_DLL_VRVCORE DtSkyObjectSignaler : public DtVirtualBaseClass
   {
   public:
      static DtSkyObjectSignaler& instance(DtDe& de);

      virtual ~DtSkyObjectSignaler();


      boost::signalslib::signal<void(DtCloudLayerId layerId)>signal_addCloudLayer;
      boost::signalslib::signal<void(DtCloudLayerId layerId)>signal_modifyCloudLayer;

      boost::signalslib::signal<void(DtCloudLayerId layerId, bool enabled) >
         signal_cloudLayerEnabledChanged;

      boost::signalslib::signal<void(DtCloudLayerId layerId) > signal_removeCloudLayer;

      boost::signalslib::signal<void ()> signal_removeCloudLayers;

      boost::signalslib::signal<void (float turbidity)> signal_airTurbidityChanged;

      boost::signalslib::signal<void (float temperature)> signal_ambientAirTemperatureChanged;

      boost::signalslib::signal<void (float distance)> signal_visibleDistanceChanged;

      boost::signalslib::signal<void (bool enabled)> signal_precipitationEnabledChanged;

      boost::signalslib::signal<void (int type)> signal_precipitationTypeChanged;

      boost::signalslib::signal<void (float intensity)> signal_precipitationIntensityChanged;

      boost::signalslib::signal<void(DtCloudLayerId layerId, double xCoord,
         double yCoord)> signal_cloudLayerPositionChanged;

      boost::signalslib::signal<void (float meters)> signal_fogHeightChanged;

      boost::signalslib::signal<void (const DtVector& color)> signal_fogColorChanged;

      boost::signalslib::signal<void (float metersPerSecond)> signal_windSpeedChanged;

      boost::signalslib::signal<void (float radians) > signal_windDirectionChanged;

      boost::signalslib::signal<void (float)> signal_ambientLightValueChanged;

      boost::signalslib::signal<void (bool)> signal_isDayChanged;

      boost::signalslib::signal<void (const DtVector& locStart, const DtVector& locEnd)> signal_lightningStrikeOccurred;

   protected:
      DtSkyObjectSignaler();
   };
}