DtSilverliningGroup.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>
#include <vrvOsg/DtSilverLiningCloudLayer.h>
#include <vrvOsg/DtOsgGlobalShaderComponent.h>

#include <osg/Camera>
#include <osg/Group>
#include <osg/Geode>
#include <osg/LightSource>
#include <osg/Uniform>
#include <osg/observer_ptr>

#include <OpenThreads/Mutex>

#include <matrix/vlVector.h>
#include <matrix/referenceEllipsoid.h>
#include <matrix/geodeticCoord.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvCore/DtVirtualBaseClassCreator.h>

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

#include <list>
#include <map>

namespace SilverLining
{
   class Atmosphere;
   class CloudLayer;
   class LocalTime;
   class Location;
   class ThreadCameraStreamData;
}

namespace makVrv
{
   class DtChannel;
   class DtDe;
   class DtOsgFogComponent;
   class DtLightManagerGroup;
   class DtOsgSkyObject;
   class DtCloudLayerManager;
   class DtWindow;

   struct DtSilverLiningFogParameters;
   class DtSilverLiningFogManager;
   class DtSilverLiningContextManager;
   class DtSilverLiningCameraManager;

   class DtSilverliningGroup;

   typedef DtVirtualBaseClassCreator<DtSilverliningGroup> DtSilverliningGroupCreator;

   template <>
   inline const char* creatorTypeName<DtSilverliningGroup>(void) { return "DtSilverliningGroupCreator"; }

   struct DtCrepuscularRaysModifiers;
   struct DtCrepuscularRaysParameters;


   class DT_DLL_VRVOSG DtSilverliningGroup : public osg::Group
   {
   public:
      friend DtSilverliningGroupCreator;

      virtual ~DtSilverliningGroup();

   protected:
      DtSilverliningGroup(DtDe& de);

   public:
      virtual void setGenerateCubeMaps(bool enabled);

      virtual unsigned int getCubeMap(const osg::ref_ptr<const osg::Camera>& osgCamera) const;

      virtual void installIntoChannel(DtChannel*);

      virtual void applyFog(osg::ref_ptr<const osg::Camera> osgCamera, bool adjustForCoverage, SilverLining::ThreadCameraStreamData* tcsData);

      virtual void deleteGeods();

      virtual void setGeocentricMode(bool mode);

      virtual bool geocentricMode() const;

      virtual void setHiResCumulus(bool enabled);

      virtual bool hiResCumulus() const;

      virtual void setLensFlare(bool enabled);

      virtual bool lensFlare() const;

      virtual void setForcedMoonPhase(float phase);

      virtual void clearForcedMoonPhase();

      virtual bool moonPhaseIsForced() const;

      virtual float forcedMoonPhase() const;

      virtual void setForcedSunAndMoon(double sunLat, double sunLon, double moonLat,
         double moonLon, bool horizonCoords = true);

      // Clear any forced sun & moon position set with ForceSunAndMoon()
      virtual void clearForcedSunAndMoon();

      virtual bool sunAndMoonPositionIsForced() const;

      virtual void getForcedSunAndMoonPosition(double& sunLat, double& sunLon,
         double& moonLat, double& moonLon, bool& horizonCoords) const;

      virtual void setLightPollution(double Wm2);

      virtual double lightPollution() const;

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

      virtual void updateTime();

      virtual void setLocation(const DtVector& location, SilverLining::ThreadCameraStreamData* tcsData, bool setForAll);

      virtual void update(const osg::Matrix& modelViewMatrix, SilverLining::ThreadCameraStreamData* tcsData);

      virtual void update2D(const osg::Matrix& m);

      virtual void updateConditions(DtOsgSkyObject* skyObject);

      virtual void removeCloudLayer(DtCloudLayerId layerId);

      virtual void removeCloudLayers();

      virtual void setFogColor(const osg::Vec4f& rgbA);

      virtual void setFogHeight(float height);

      virtual void setFogBlend(const osg::Vec4f& rgbA, float density);

      virtual void setFogOverride(osg::ref_ptr<const osg::Camera> osgCamera, const osg::Vec4f& rgbA, float density);

      virtual void setFogThresholdDistance(float distance);

      virtual void setHorizonColor(const osg::Vec4f& rgbA);

      virtual void setCubeMapDirty();

      virtual void setUse16BitEnviroMap(bool flag);

      virtual bool getUse16BitEnviroMap();

      virtual void setUsingSensorFXShader(bool flag);

      virtual bool getUsingSensorFXShader();

      virtual void clearHorizonColor();

      virtual void clearFogOverride(osg::ref_ptr<const osg::Camera> osgCamera);

      virtual void clearFogOverrideForAllCameras(void);

      void setUseGlobalTimeZone(bool b);

      virtual bool useGlobalTimeZone() const;

      virtual float getSunAlpha() const;

      virtual void setDrawSunAndMoonIntoEnvMap(bool draw);

      virtual bool drawSunAndMoonIntoEnvMap() const;

      virtual float getSkyCoverage() const;

      virtual void addCirroCumulus(DtCloudLayerId layerId, const DtVector& position, float orientation,
         const DtVector& bounds, bool infinite, bool relative, bool fadeAtAltitude, bool altitudeIsHAT);

      virtual void addCirroStratus(DtCloudLayerId layerId, const DtVector& position, float orientation,
         const DtVector& bounds, bool infinite, bool relative, bool fadeAtAltitude, bool altitudeIsHAT);

      virtual void addCirrusFibratus(DtCloudLayerId layerId, const DtVector& position, float orientation,
         const DtVector& bounds, bool infinite, bool relative, bool fadeAtAltitude, bool altitudeIsHAT);

      virtual void addNimbostratus(DtCloudLayerId layerId, const DtVector& position, float orientation,
         const DtVector& bounds, double density, bool infinite, bool relative, bool fadeAtAltitude, bool altitudeIsHAT);

      virtual void addCumulusMediocris(DtCloudLayerId layerId, const DtVector& position, float orientation,
         float cornerRadius, const DtVector& bounds, double density, bool infinite, bool relative, bool fadeAtAltitude,
         bool altitudeIsHAT);

      virtual void addCumulusCongestus(DtCloudLayerId layerId, const DtVector& position, float orientation,
         float cornerRadius, const DtVector& bounds, double density, bool infinite, bool relative, bool fadeAtAltitude,
         bool altitudeIsHAT);

      virtual void addCumulonimbusCappilatus(DtCloudLayerId layerId, const DtVector& position, float orientation,
         const DtVector& bounds, double density, bool relative, bool fadeAtAltitude, bool altitudeIsHAT);

      virtual void addStratocumulus(DtCloudLayerId layerId, const DtVector& position, float orientation,
         float cornerRadius, const DtVector& bounds, double density, bool infinite, bool relative, bool fadeAtAltitude, bool altitudeIsHAT);

      virtual void addGroundFog(DtCloudLayerId layerId, const DtVector& position, float orientation, float cornerRadius,
         const DtVector& bounds, double density, bool infinite, bool relative, bool fadeAtAltitude, bool altitudeIsHAT);

      virtual void setCloudLayerEnabled(DtCloudLayerId layerId, bool enabled, SilverLining::ThreadCameraStreamData* tcsData, bool setForAll);
      virtual void setCloudLayerPositionAndOrientation(DtCloudLayerId layerId, const DtVector& position, float orientation, SilverLining::ThreadCameraStreamData* tcsData, bool setForAll);

      virtual void setWind(const double directionDEN, const double minAltitude,
         const double maxAltitude, const double velocity);

      virtual void setAirTurbidity(float turbidity);
      virtual void setVisibleDistance(float distance, SilverLining::ThreadCameraStreamData* tcsData, bool setForAll);
      virtual float getVisibleDistance() const;

      virtual void createAtmosphere();
      virtual void destroyAtmosphere();

      // if create atmosphere failed this is set to true.
      virtual bool getFailedInit() { return myFailedInit; }

      virtual void addRain(float mmPerHour, bool global);
      virtual void addSleet(float mmPerHour, bool global);
      virtual void addSnow(float mmPerHour, bool global, bool wet);
      virtual void clearAllPrecipitation(SilverLining::ThreadCameraStreamData* tcsData);

      virtual bool realizeLayers(SilverLining::ThreadCameraStreamData* tcsData);

      virtual SilverLining::Atmosphere* findAtmosphere();
      virtual const SilverLining::Atmosphere* findAtmosphere() const;

      //get the Julian Date and Time in the GMT time zone
      virtual void getGMTDateTime(long &julianDate, double &GMTTod);

      //return the node that is the parent to the clouds
      virtual osg::Node *getCloudsNode();

      //return the node that is the parent to the sky
      virtual osg::Node *getSkyNode();

      //set the flag for drawing the silverlining sun/moon
      virtual void setSunMoonEnabled(bool drawSunMoon);

      //get the flag for drawing the silverlining sun/moon
      virtual bool sunMoonEnabled();

      //set the flag for drawing the silverlining stars
      virtual void setStarsEnabled(bool drawStars);

      //get the flag for drawing the silverlining stars
      virtual bool starsEnabled();

      virtual void enableLighting(osg::ref_ptr<osg::Camera> osgCamera, bool enable);

      void setEnableHDR(bool enable);

      virtual osg::LightSource *skyLight();

      virtual const CloudLayerMap& cloudLayerMap() const;

      virtual osg::Vec3f & getLastUpVector() { return myLastUpVector; }

      virtual void fillCrepuscularRaysParameters(DtCrepuscularRaysParameters& params, const osg::Camera* osgCamera) const;

      virtual void updateImGuiAndGetModifiersOffOfImgGui(DtCrepuscularRaysModifiers& modifiers
         , float r, float g, float b
         , float sunPosX, float sunPosY, float sunPosZ
         , float exposure) const;

      virtual void slot_windowToBeDestroyed(DtWindow* window);

      virtual void addGraphicsContextIfNecessary(const osg::Camera* osgCamera);

      const DtSilverLiningCameraManager* silverLiningCameraManager(void) const;

      DtSilverLiningCameraManager* silverLiningCameraManager(void);

      const DtCloudLayerManager* cloudLayerManager(void) const;

      DtCloudLayerManager* cloudLayerManager(void);
   protected:

      virtual void addLayer(DtCloudLayerId layerId, const DtSilverLiningCloudLayer& layer);

      virtual void destroyLayer(const DtSilverLiningCloudLayer& layer);

      virtual int CalculateZoneByLongitude(double longitude) const;

      void SetTimeAndLocation();

      virtual void addPrecipitationToClouds(int type, float mmPerHour);

      virtual void updatePrecipitation(SilverLining::ThreadCameraStreamData* tcsData, const DtVector& location);

      virtual void setCloudVisibility(SilverLining::ThreadCameraStreamData* tcsData, bool setForAll);

      virtual void traverse(osg::NodeVisitor& nv);
      virtual void resetLayers();
      virtual void forceResetLayers();

      virtual void updateCubeMap(void);

      virtual void slot_reloadShader();

      //Setup the light override IMGUI sliders which allow for debug overriding of light position
      virtual void updateLightOverrideGui(float x, float y, float z);

      virtual void calculateAndFillFogParameters(DtSilverLiningFogParameters& fogParameters, bool adjustCoverage, SilverLining::ThreadCameraStreamData* tcsData) const;

      virtual void createFogAttributeIfNeeded(void);

   protected:

      DtDe & myDe;
      mutable OpenThreads::Mutex  myMutex;

      DtReferenceEllipsoid myRefEllip;
      DtGeodeticCoord myGeod;

      SilverLining::Atmosphere* myAtmosphere;
      SilverLining::LocalTime* myLocalTime;
      SilverLining::Location* myLocation;

      DtCloudLayerManager* myLayerManager;

      osg::ref_ptr<osg::Geode> mySkyGeode;
      osg::ref_ptr<osg::LightSource> mySkyLight;
      osg::ref_ptr<osg::Geode> myCloudGeode;
      osg::ref_ptr<DtLightManagerGroup> myLightManagerGroup;

      osg::Vec4f myFogColor, myBlendedFogColor, myHorizonColor;
      osg::Vec3f myLastUpVector;
      osg::Vec2f myWind;

      bool myHasFixedHorizonColor;
      float myFogDensity;

      float myVisibility;
      float myTurbidity;
      bool myGeocFlag;
      bool myNeedsResetFlag;
      int myCubeMapDirtyState;
      bool myCubeMapFullRegenerate;
      bool myCubeMapEnabled;
      bool myLensFlareEnabled;

      bool myMoonPhaseForced;
      float myForcedMoonPhase;
      bool mySunAndMoonPositionForced;
      float myForcedSunLat;
      float myForcedSunLon;
      float myForcedMoonLat;
      float myForcedMoonLon;
      bool myForcedSunAndMoonUsingHorizonCoords;
      bool myHiResCumulus;
      bool myDrawSunAndMoonIntoEnvMap;

      bool myUse16BitEnviroMap;
      bool myUsingSensorFXShader;

      osg::ref_ptr<osg::Uniform> myLightLevelUniform;
      osg::ref_ptr<osg::Uniform> myLightAmbientUniform;

      float myFogHeight, myFogThresholdDistance;
      float mySunAlpha;
      bool myCurveCloudsTowardGround;

      int myGlobalPrecipitationType;
      float myGlobalPrecipitationIntensity;

      bool myForceRelight;

      osg::ref_ptr<DtOsgFogComponent> myFogComponent;

      osg::ref_ptr<DtOsgGlobalShaderComponent> myGlobalShaderComponent;

      //default OpenGL compiled shaders needed for silver lining to work after sensorFX is installed
      std::vector<unsigned int> myDefaultShaderVector;

      bool myDrawStars;
      bool myDrawSunMoon;

      DtSignalConnectionManager myConnections;

      bool myUseGlobalTimeZone;
      bool myFailedInit;

      bool myLastAtmosphereFogEnabled;
      std::string myOriginalVoxelDimension;

      bool myOverrideLightPositionEnabled;
      osg::Vec3f myOverrideLightPosition;
      double myLastImGuiSimTime;
      bool myUseAzimuthElevationForOverrideGui;

      DtSilverLiningFogManager* myFogManager;
      DtSilverLiningContextManager* myContextManager;
      DtSilverLiningCameraManager* myCameraManager;
   };
}