DtSilverliningGroup.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2020 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 <vrvUtil/DtVirtualBaseClass.h>

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

#include <boost/unordered_map.hpp>
#include <list>
#include <map>

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

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

   struct DtCrepuscularRaysModifiers;
   struct DtCrepuscularRaysParameters;

   class DT_DLL_VRVOSG DtSilverliningGroup : public osg::Group
   {
   public:

      DtSilverliningGroup(DtDe& de);

      virtual ~DtSilverliningGroup();

      DtDe& getDe() { return myDe; }

      virtual void setGenerateCubeMaps(bool enabled);

      void setCubeMapGenerationDistanceThreshold(double threshold);

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

      virtual unsigned int getPrimaryCubeMap() const;

      virtual void installIntoChannel(DtChannel*);

      virtual void applyFog(osg::ref_ptr<const osg::Camera> camera);

      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 setCrepuscularRays(bool enabled);

      virtual bool crepuscularRays() 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);

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

      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> camera, 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> camera);

      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 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, 
         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);
      virtual void setCloudLayerPositionAndOrientation(DtCloudLayerId layerId, const DtVector& position, float orientation);

      virtual void setWind(double directionDEN, double minAltitude, double maxAltitude, double velocity);
      virtual void setAirTurbidity(float turbidity);
      virtual void setVisibleDistance(float distance);
      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();

      virtual void realizeLayers();

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

      DtDe& getDtDe();

      //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 getSunMoonEnabled();

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

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

      virtual void enableLighting(osg::ref_ptr<osg::Camera> camera, 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;

      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(osg::GraphicsContext* key);

   protected:

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

      virtual void destroyLayer(const DtSilverLiningCloudLayer& layer);

      virtual int CalculateZoneByLongitude(double longitude);
      void SetTimeAndLocation();

      virtual void addPrecipitationToClouds(int type, float mmPerHour);

      virtual void updatePrecipitation();

      virtual void setCloudVisibility();

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

      virtual void generateCubeMap(const osg::Matrix& viewMatrix);

      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);

      
   protected:

      typedef std::vector<DtSilverLiningCloudLayer> CloudLayerList;

      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;

      bool myHasFixedHorizonColor;
      float myFogDensity;

      float myVisibility;
      float myTurbidity;
      bool myGeocFlag;
      bool myNeedsResetFlag;
      int myCubeMapDirtyState;
      bool myCubeMapFullRegenerate;
      bool myCubeMapEnabled;
      bool myLensFlareEnabled;
      bool myCrepuscularRaysEnabled;
      bool myMoonPhaseForced;
      float myForcedMoonPhase;
      bool mySunAndMoonPositionForced;
      float myForcedSunLat;
      float myForcedSunLon;
      float myForcedMoonLat;
      float myForcedMoonLon;
      bool myForcedSunAndMoonUsingHorizonCoords;
      bool myHiResCumulus;
      bool myDrawSunAndMoonIntoEnvMap;

      bool myUse16BitEnviroMap;
      bool myUsingSensorFXShader;

      typedef std::map<osg::observer_ptr<const osg::Camera>, bool> FogOverrideMap;

      FogOverrideMap myOverrideFogMap;
      std::map<osg::observer_ptr<const osg::Camera>, float> myFogOverrideDensityMap;
      std::map<osg::observer_ptr<const osg::Camera>, osg::Vec4f> myFogOverrideColorMap;

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

      float myFogHeight, myFogThresholdDistance;
      float mySunAlpha;
      bool myCurveCloudsTowardGround;

      bool myPrecipitationStateSaved;
      int mySavedPrecipitationType;
      float mySavedPrecipitationIntensity;

      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;

      typedef std::map< osg::GraphicsContext*, void* > ContextToHandleMap;
      ContextToHandleMap myOsgGcToOsGc;

   };

   class DT_DLL_VRVOSG DtSilverliningGroupCreator : public DtVirtualBaseClass
   {

   public:
      static DtSilverliningGroupCreator& instance(DtDe& theIG);

      static void registerInstance(DtDe& theIG, DtSilverliningGroupCreator* anInstance);

      virtual DtSilverliningGroup* create(DtDe&);
   };
}