DtOsgSkyObject.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/DtSilverliningGroup.h>
#include <vrvCore/DtSkyObject.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <osgParticle/PrecipitationEffect>
#include <osg/TextureCubeMap>

namespace makVrv
{
   class DtDe;
   class DtWaterOnScreen;

   class DT_DLL_VRVOSG DtPrecipitationEffect : public osgParticle::PrecipitationEffect
   {
   public:
      DtPrecipitationEffect();
      DtPrecipitationEffect(const DtPrecipitationEffect& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY);
      ~DtPrecipitationEffect();

      virtual const char* libraryName() const { return "vrvOsg"; }
      virtual const char* className() const { return "DtPrecipitationEffect"; }
      virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const DtPrecipitationEffect*>(obj) != 0; }
      
      virtual void traverse(osg::NodeVisitor& nv);
   };

   class DT_DLL_VRVOSG DtOsgSkyObject : public DtSkyObject
   {
   public:

      DtOsgSkyObject(DtDe&, DtUniqueID id);

      virtual ~DtOsgSkyObject();

      virtual void setLocation(const DtVector& location);

      virtual const DtVector& location() const;

      virtual void addCloudLayer(int deckType, const DtVector& location, 
         const DtVector& bounds, double density, bool infinite, bool relative);

      virtual bool cloudLayer(int index, int& deckType, DtVector& location, 
         DtVector& bounds, double& density, bool& infinite, bool& relative) const;

      virtual int cloudLayerCount() const;     

      virtual void removeCloudLayer(int index);

      virtual void removeCloudLayers();

      virtual void sendCloudLayers();

      virtual void setCloudLayerEnabled(int index, bool enabled);

      virtual float getSunAlpha() const;

      virtual void setDrawSunAndMoonIntoEnvMap(bool draw);

      virtual void setAirTurbidity(float turbidity);
      virtual float airTurbidity() const;

      virtual void setAmbientAirTemperature(float temperature);
      virtual float ambientAirTemperature() const;

      virtual void setVisibleDistance(float distance);
      virtual float visibleDistance() const;

      virtual void setFogHeight(float meters);
      virtual float fogHeight() const;

      virtual void setFogColor(const DtVector& color);
      virtual const osg::Vec4& fogColor() const;

      virtual void setFogThresholdDistance(float distance);
      virtual float fogThresholdDistance() const;

      virtual void setPrecipitationEnabled(bool enabled);
      virtual bool precipitationEnabled() const;

      virtual void setPrecipitationVisibilityEffectsEnabled(bool enabled);
      virtual bool precipitationVisibilityEffectsEnabled() const;

      virtual void setPrecipitationType(int type);
      virtual int precipitationType() const;

      virtual void setPrecipitationIntensity(float intensity);
      virtual float precipitationIntensity() const;

      virtual void setCloudLayerPosition(
         int index, double xCoord, double yCoord);

      virtual void setWindSpeed(float metersPerSecond);
      virtual float windSpeed() const;

      
      virtual void setWindDirection(float radians);
      virtual float windDirection() const;
      virtual float windDirectionInDegrees() const;
      

      virtual void setMinimumWindAltitude(float alt);
      virtual float minimumWindAltitude() const;

      virtual void setMaximumWindAltitude(float alt);
      virtual float maximumWindAltitude() const;

      virtual void setLensFlare(bool enabled);
      virtual bool lensFlare() const;

      virtual void setCrepuscularRays(bool enabled);
      virtual bool crepuscularRays() const;

      virtual void setRainSplashEffect();

      void setGenerateCubeMaps(bool enabled);

      GLuint getCubeMap(const osg::ref_ptr<osg::Camera> camera, const osg::State &state) const;

      GLuint getPrimaryCubeMap() const;

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

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

      void clearFogOverrideForAllCameras(void);

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

      void clearHorizonColor();

      void updatePrecipitation();

      DtSilverliningGroup *getDtSilverlining();

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

      bool shouldActivateRaindrops() const;

   protected:

      void updatePrecipitationOSG();
      void updatePrecipitationSilverLining();

      void on_coordinateSystemChanged(const std::string& type);

      void applyCurrentSettings();

   protected:

      class CloudLayer
      {
      public:
         CloudLayer(int type=0, const DtVector& location=DtVector(0, 0, 0), 
            const DtVector& bounds=DtVector(0, 0, 0), double density=0.0, 
            bool infinite=false, bool relative=false)
            : myType(type)
            , myLocation(location)
            , myBounds(bounds)
            , myDensity(density)
            , myInfinite(infinite)
            , myRelative(relative)
            , myEnabled(false)
         {}

      public:
         int myType;
         DtVector myLocation;
         DtVector myBounds;
         double myDensity;
         bool myInfinite;
         bool myRelative;
         bool myEnabled;
      };
      typedef std::vector<CloudLayer> CloudLayerList;

      DtDe& myDe;
      DtSignalConnectionManager mySignals;
      osg::ref_ptr<DtSilverliningGroup> mySilverliningGroup;
      DtVector myLocation;
      CloudLayerList myCloudLayerList;
      osg::ref_ptr<osgParticle::PrecipitationEffect> myPrecipitationEffect;
      bool myPrecipitationEnabled;
      int myPrecipitationEffectType;
      float myPrecipitationIntensity;
      float myAirTurbidity;
      float myAirTemperature;
      float myVisibleDistance;
      float myFogHeight;
      osg::Vec4f myFogColor;
      float myFogThreshold;
      float myWindSpeed;
      float myWindDirection;
      float myWindAltMinimum;
      float myWindAltMaximum;
      bool myLensFlareEnabled;
      bool myCrepuscularRaysEnabled;
      bool myVisibilitySaved;
      float mySavedVisibility;
      bool myPrecipitationVisibilityEffects;

      //default cube map for when the sky is turned off.
      osg::ref_ptr<osg::TextureCubeMap> myDefaultCubeMap;

   };
}