DtSilverliningGroup.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2017 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>

#include <vrvCore/DtCloudLayer.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:

        struct CloudLayer
        {
            unsigned int type;
            unsigned int handle;
            DtVector position;
            DtVector bounds;
            double density;
            bool enabled;
            bool realized;
            bool infinite;
            bool relative;
        };
        typedef std::vector<CloudLayer> CloudLayerList;
        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<osg::Camera>& camera) const;

        virtual unsigned int getPrimaryCubeMap() const;

        virtual void installIntoChannel(DtChannel*);

        virtual void applyFog(osg::ref_ptr<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 int cloudLayerCount() const;

        virtual void removeCloudLayer(int index);

        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<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<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(const DtVector& position, const DtVector& bounds, bool infinite, bool relative);
        virtual void addCirrusFibratus(const DtVector& position, const DtVector& bounds, bool infinite, bool relative);
        virtual void addNimbostratus(const DtVector& position, const DtVector& bounds, double density, bool infinite, bool relative);
        virtual void addCumulusMediocris(const DtVector& position, const DtVector& bounds, double density, bool infinite, bool relative);
        virtual void addCumulusCongestus(const DtVector& position, const DtVector& bounds, double density, bool infinite, bool relative);
        virtual void addCumulonumbusCappilatus(const DtVector& position, const DtVector& bounds, double density, bool relative);
        virtual void addStratocumulus(const DtVector& position, const DtVector& bounds, double density, bool infinite, bool relative);
        virtual void setCloudLayerEnabled(int index, bool enabled);
        virtual void setCloudLayerPosition(int index, double xCoord, double yCoord);

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

        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 CloudLayerList& cloudLayerList() const;

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

        virtual bool updateVolumetricUniforms(osg::StateSet * stateSet);

    protected:

        virtual void addLayer(const CloudLayer& layer);

        virtual void realizeLayer(CloudLayer& layer);
        virtual void destroyLayer(DtSilverliningGroup::CloudLayer& 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();


    protected:

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

        bool myLastAtmosphereFogEnabled;
        std::string myOriginalVoxelDimention;


    };

    class DT_DLL_VRVOSG DtSilverliningGroupCreator : public DtVirtualBaseClass
    {

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

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

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