DtSilverliningGroup.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

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

#include <OpenThreads/Mutex>

#include <list>
#include <map>

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

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

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

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

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

      DtSilverliningGroup(DtDe& de);      

      virtual ~DtSilverliningGroup();
      
      void setGenerateCubeMaps(bool enabled);

      void setCubeMapGenerationDistanceThreshold(double threshold);

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

      void installIntoChannel(DtChannel*);

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

      void deleteGeods();

      void setGeocentricMode(bool mode);

      bool geocentricMode() const;

      void setHiResCumulus(bool enabled);

      bool hiResCumulus() const;

      void setLensFlare(bool enabled);

      bool lensFlare() const;

      void setCrepuscularRays(bool enabled);

      bool crepuscularRays() const;

      void setForcedMoonPhase(float phase);

      void clearForcedMoonPhase();

      bool moonPhaseIsForced() const;

      float forcedMoonPhase() const;

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

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

      bool sunAndMoonPositionIsForced() const;

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

      void setLightPollution(double Wm2);

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

      int cloudLayerCount() const;

      void removeCloudLayer(int index);

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

      void setFogHeight(float height);

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

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

      void setFogThresholdDistance(float distance);

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

      void setCubeMapDirty();

      void setUse16BitEnviroMap(bool flag);
      
      bool getUse16BitEnviroMap();

      void setUsingSensorFXShader(bool flag);
      
      bool getUsingSensorFXShader();

      void clearHorizonColor();

      void clearFogOverride(osg::ref_ptr<osg::Camera> camera);

      void clearFogOverrideForAllCameras(void);

      virtual void setUseGlobalTimeZone(bool b);

      virtual bool useGlobalTimeZone() const;

      float getSunAlpha() const;

      void setDrawSunAndMoonIntoEnvMap(bool draw);

      bool drawSunAndMoonIntoEnvMap() const;

      void addCirroCumulus(const DtVector& position, const DtVector& bounds, bool infinite, bool relative);
      void addCirrusFibratus(const DtVector& position, const DtVector& bounds, bool infinite, bool relative);
      void addNimbostratus(const DtVector& position, const DtVector& bounds,double density, bool infinite, bool relative);
      void addCumulusMediocris(const DtVector& position, const DtVector& bounds,double density, bool infinite, bool relative);
      void addCumulusCongestus(const DtVector& position, const DtVector& bounds,double density, bool infinite, bool relative);
      void addCumulonumbusCappilatus(const DtVector& position, const DtVector& bounds,double density, bool relative);
      void addStratocumulus(const DtVector& position, const DtVector& bounds, double density, bool infinite, bool relative);
      void setCloudLayerEnabled(int index, bool enabled);
      void setCloudLayerPosition(int index, double xCoord, double yCoord);

      void setWind(double directionDEN,double minAltitude, double maxAltitude,double velocity);      
      void setAirTurbidity( float turbidity );
      void setVisibleDistance( float distance );
      float getVisibleDistance() const;

      void createAtmosphere();
      void destroyAtmosphere();

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

      void addRain(float mmPerHour, bool global);
      void addSleet(float mmPerHour, bool global);
      void addSnow(float mmPerHour, bool global, bool wet);
      void clearAllPrecipitation();

      void realizeLayers();

      SilverLining::Atmosphere* findAtmosphere();

      DtDe& getDtDe();

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

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

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

      //return the default shader vector being used for the atmosphere user functions
      std::vector<unsigned int> getDefaultShaderVector();

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

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

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

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

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

     virtual void setEnableHDR(bool enable);


   protected:

      struct CloudLayer
      {
         unsigned int type;
         unsigned int handle;
         DtVector position;
         DtVector bounds;
         double density;
         bool enabled;
         bool realized;
         bool infinite;
         bool relative;
      };

      void addLayer( const CloudLayer& layer );

      void realizeLayer( CloudLayer& layer );
      void destroyLayer( DtSilverliningGroup::CloudLayer& layer );

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

      void addPrecipitationToClouds(int type, float mmPerHour);

      void updatePrecipitation();

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

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


   protected:

      typedef std::vector<CloudLayer> CloudLayerList;

      DtDe& myDe;
      mutable OpenThreads::Mutex  myMutex;

      DtReferenceEllipsoid myRefEllip;
      DtGeodeticCoord myGeod;

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

      CloudLayerList myLayers;
      CloudLayerList myDestroyedLayers;

      osg::ref_ptr<osg::Geode> mySkyGeod;
      osg::ref_ptr<osg::LightSource> mySkyLight;
      osg::ref_ptr<osg::Geode> myCloudGeod;
      osg::ref_ptr<DtLightManagerGroup> myLightManagerGroup;

      osg::Vec4f myFogColor, myBlendedFogColor, myHorizonColor;
      bool myHasFixedHorizonColor;
      float myFogDensity;

      float myVisibility;
      float myTurbidity;
      bool myGeocFlag;
      bool myNeedsResetFlag;
      bool myCubeMapDirty;
      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::ref_ptr<osg::Camera>, bool> FogOverrideMap;

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

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

      float myFogHeight, myFogThresholdDistance;
      float mySunAlpha;
      bool myCurveCloudsTowardGround;

      bool myPrecipitationStateSaved;
      int mySavedPrecipitationType;
      float mySavedPrecipitationIntensity;

      bool myForceRelight;

      osg::ref_ptr<DtOsgFogComponent> myFogComponent;
      bool myFogInstalled;
      
      //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;
   };

   class DT_DLL_VRVOSG DtSilverliningGroupCreator : public DtVirtualBaseClass
   {

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

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

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