DtSilverliningGroup.h

Go to the documentation of this file.

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


#pragma once

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

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

#include <vrvUtil/DtSignalConnectionManager.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 <tbb/concurrent_queue.h>

#include <list>
#include <map>
#include <mutex>

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

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

   class DtSilverLiningFogParameters;
   class DtSilverLiningCubeMapData;
   class DtSilverLiningGroupTcsUserData;
   class DtGlDeleteObjectManager;
   class DtOsgLightManager;


   class DtSilverliningGroup;

   typedef DtVirtualBaseClassCreator<DtSilverliningGroup> DtSilverliningGroupCreator;

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

   struct DtCrepuscularRaysModifiers;
   struct DtCrepuscularRaysParameters;

   class DtDtSilverLiningGroupCameraObserver : public osg::Observer
   {
   public:
      virtual void objectDeleted(void*) override;
   public:
      DtSilverliningGroup* myParent = nullptr;
   };

   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 findCubeMap(const osg::ref_ptr<const osg::Camera>& osgCamera) const;

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

      virtual void deleteGeods();

      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;

      DtVector3<float> sunOrMoonPosition(const osg::Camera* osgCamera) const;

      virtual void setLightPollution(double Wm2);

      virtual double lightPollution() const;

      virtual void setLocation(const DtVector& location, osg::ref_ptr<const osg::Camera> osgCamera, SilverLining::ThreadCameraStreamData* tcsData, bool useGlobalTimeZoneOverride, bool updateTimeInAtmosphere);

      virtual void update(const osg::Matrix& modelViewMatrix, osg::ref_ptr<const osg::Camera> osgCamera, SilverLining::ThreadCameraStreamData* tcsData);

      virtual void update2D(const osg::Matrixd& m, const osg::Camera* osgCamera);

      virtual void removeCloudLayer(DtCloudLayerId layerId);

      virtual void removeCloudLayers();

      virtual void setFogColor(const Vector4_32& rgbA);

      virtual void setFogHeight(float height);

      virtual void setFogBlend(const Vector4_32& rgbA, float density);

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

      virtual void setFogThresholdDistance(float distance);

      virtual void setHorizonColor(const Vector4_32& 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);


      virtual bool useGlobalTimeZone() const;

      virtual float sunAlpha(const osg::Camera* osgCamera) const;

      virtual void setDrawSunAndMoonIntoEnvMap(const osg::Camera* osgCamera, bool draw);

      virtual float getSkyCoverage(osg::ref_ptr<const osg::Camera> osgCamera) 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);
      virtual void setCloudLayerPositionAndOrientation(DtCloudLayerId layerId, const DtVector& position, float orientation);

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

      virtual const Vector2_32& wind(void) const;

      virtual void setAirTurbidity(float turbidity);
      virtual void setVisibleDistance(const osg::Camera* osgCamera, float distance);
      virtual float getVisibleDistance() const;

      virtual void createAtmosphere();

      // 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
         , DtSilverLiningGroupTcsUserData* userData);

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

      //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(const osg::Camera* osgCamera);

      virtual const osg::LightSource* skyLight(const osg::Camera* osgCamera) const;

      virtual const CloudLayerMap& cloudLayerMap() const;

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

      virtual const DtCloudLayerManager* cloudLayerManager(void) const;

      virtual DtCloudLayerManager* cloudLayerManager(void);

      virtual DtOsgFogComponent* findFogComponent() const;

      virtual std::string userDefinedVertString(void) const;
      virtual std::string userDefinedFragString(void) const;

      virtual DtSilverLiningGroupTcsUserData* getOrCreateUserData(const osg::Camera* osgCamera);

      virtual DtSilverLiningGroupTcsUserData* findUserData(const osg::Camera* osgCamera);

      virtual const DtSilverLiningGroupTcsUserData* findUserData(const osg::Camera* osgCamera) const;

      virtual SilverLining::ThreadCameraStreamData* findSilverLiningTcsData(const osg::Camera* osgCamera);

      virtual SilverLining::ThreadCameraStreamData* findSilverLiningTcsData(const osg::Camera* osgCamera) const;

      virtual void reloadShaders(const std::vector<unsigned int>& shaderVector
         , const std::string& userDefinedVertString, const std::string& userDefinedFragString);

      virtual float fogDensity(const osg::Camera* osgCamera) const;

      virtual Vector4_32 fogColor(const osg::Camera* osgCamera) const;

      virtual Vector4_32 ambientColor(const osg::Camera* osgCamera) const;

      virtual Vector4_32 diffuseColor(const osg::Camera* osgCamera) const;

      virtual Vector3_32 lightPosition(const osg::Camera* osgCamera) const;

      virtual float smoothingDistance(void) const;

      virtual const DtThreadCameraStreamDataManagerBase* tcsDataManager(void) const;

      virtual DtThreadCameraStreamDataManagerBase* tcsDataManager(void);

      virtual void setCubeMapDirtyState(int val);

      virtual DtCloudDrawable* cloudDrawable(void);

      virtual void clearCachedProgramsAndUniformLocations(DtThreadCameraStreamDataManagerBase* tcsDataManager);

      virtual DtSilverLiningGroupSkyLightTcsUserData* getOrCreateSkyLightUserData(const osg::Camera* osgCamera);

      virtual const DtSilverLiningGroupSkyLightTcsUserData* findSkyLightUserData(const osg::Camera* osgCamera) const;

      static void enableBillboardRotation(bool val);
      static bool billboardRotationEnabled();

      static double maxPrecipitationAltitude(void);
   protected:

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


      virtual int calculateZoneByLongitude(double longitude) const;

      virtual void setDateAndTime(unsigned short year, unsigned char month, unsigned char day
         , unsigned char hour, unsigned char minutes, double seconds
         , osg::ref_ptr<const osg::Camera> osgCamera
         , bool observeDaylightSavings, bool useGlobalTimeZoneOverride
         , bool updateTimeInAtmosphere);
         
      virtual void fillConditionsFromSkyObjectAtCreation(DtOsgSkyObject* skyObject);

      virtual void addPrecipitationToClouds(int type, float mmPerHour);

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

      virtual void setCloudVisibility(const osg::Camera* osgCamera, SilverLining::ThreadCameraStreamData* slTcsData, SilverLining::Location* slLocation);

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

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

      virtual void slot_reloadShader();

      //Setup the light override/smoothing override IMGUI sliders which allow for debug overriding of light position
      virtual void updateImGui(float& x, float& y, float& z, SilverLining::ThreadCameraStreamData* slTcsData
         , SilverLining::Location* slLocation);

      virtual void calculateAndFillFogParameters(osg::ref_ptr<const osg::Camera> osgCamera, SilverLining::ThreadCameraStreamData* slTcsData, SilverLining::Location* slLocation
         , DtSilverLiningFogParameters& fogParameters, bool adjustCoverage) const;

      virtual bool isTimeAndZoneTheSameExcludingMinutesAndSeconds(const SilverLining::LocalTime* lhs, const SilverLining::LocalTime* rhs) const;

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

      virtual void fillRaysParameters(SilverLining::Vector3& sunClipPos, SilverLining::Vector4& slparams, const SilverLining::ThreadCameraStreamData* tcsData, const SilverLining::Atmosphere* atmosphere) const;

      virtual void computeSunPositionClipSpace(SilverLining::Vector3& sunClip, bool& clipped, bool& behind, const SilverLining::Vector3& sunWorld, const SilverLining::ThreadCameraStreamData* tcsData) const;

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

      virtual const osg::Camera* actualCameraIfMultiView(const osg::Camera* _osgCamera) const;

      virtual void destroyAtmosphere(SilverLining::Atmosphere* atmosphere);
      
      virtual void releaseAtmosphere();
    
      virtual void objectDeleted(void* object);

      virtual void deleteSlTcsData(SilverLining::ThreadCameraStreamData* slTcsData
      , SilverLining::Atmosphere* atmosphere);

      virtual int numOutstandingUserDatas(DtThreadCameraStreamDataManagerBase* tcsDataManager) const;

      virtual void copySlTcsDatasTo(tbb::concurrent_queue<SilverLining::ThreadCameraStreamData*>& slTcsDatas) const;

      virtual void markForceRelight(DtThreadCameraStreamDataManagerBase* tcsDataManager);
   protected:

      DtDe & myDe;
      mutable OpenThreads::Mutex  myMutex;

      SilverLining::Atmosphere* myAtmosphere;
      
      DtCloudLayerManager* myLayerManager;

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

      Vector4_32 myFogColor, myBlendedFogColor, myHorizonColor;
      Vector2_32 myWind;

      bool myHasFixedHorizonColor;
      float myFogDensity;

      float myVisibility;
      float myTurbidity;
      bool myCubeMapEnabled;

      bool myMoonPhaseForced;
      float myForcedMoonPhase;
      bool mySunAndMoonPositionForced;
      float myForcedSunLat;
      float myForcedSunLon;
      float myForcedMoonLat;
      float myForcedMoonLon;
      bool myForcedSunAndMoonUsingHorizonCoords;
      
      float myStratocumulusVoxelDimension;

      bool myUse16BitEnviroMap;
      bool myUsingSensorFXShader;

      float myFogHeight, myFogThresholdDistance;
      

      int myGlobalPrecipitationType;
      float myGlobalPrecipitationIntensity;

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

      // imgui overrides
      double myLastImGuiSimTime;
      // imgui for light override
      bool myOverrideLightPositionEnabled;
      Vector3_32 myOverrideLightPosition;
      bool myUseAzimuthElevationForOverrideGui;
      // imgui for smoothing override
      bool myEnableSmoothClouds;
      float mySmoothCloudsDist;

      DtSilverLiningGroupTcsUserDataCreator& myUserDataCreator;

      DtGlDeleteObjectManager& myGlDeleteObjectManager;
      static std::atomic<int> theSlTcsDatasCount;
      static const bool theSlTcsDatasCountLog;

      // This is used to set a unique name for the sl tcs data cameras as they come in/go out of the system
      static std::atomic<int> theCameraId;

      static const float theDefaultCubeMapUpdateAndRelightTime;

      // beyond this, atmosphere time gets set again
      static const float theAtmosphereTresholdTrigger; // used to be 0.1; but 0.2 is frequent enough

      static bool theBillboardRotationEnabled;

      static const double theGeocTrueLightingAltitude;
      static const double theMaxPrecipitationAltitude;
      static const double theMaximumCloudVisibility;
      static const double theSkyFogginess;
      static const double theSkyHazeHeightFactor;
      static const double theSunAlphaFactor;

      static DtDtSilverLiningGroupCameraObserver theCameraObserver;
      
      friend class DtDtSilverLiningGroupCameraObserver;
      friend class DtSlTcsDataDeleter;

      DtThreadCameraStreamDataManager& myGlobalTcsDataManager;
      DtSilverLiningGroupSkyLightTcsUserDataCreator& mySkyLightUserDataCreator;

      DtOsgLightManager& myOsgLightManager;
   };
}