DtCloudDrawable.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/DtDe.h>
#include <vrvOsg/vrvOsg.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <osg/Camera>
#include <osg/Drawable>
#include <map>

namespace SilverLining
{
   class Atmosphere;
   class CloudLayer;
}

namespace makVrv
{
   class DtSilverliningGroup;
   class DtGlRenderTexture;
   class DtChannelManager;
   class DtChannel;

   class DT_DLL_VRVOSG DtCloudDrawable : public osg::Drawable
   {
   public:

      enum CubeMapUpdateState
      {
         CUBEMAP_CLEAN = 0
         , CUBEMAP_RENDER = 1
         , CUBEMAP_MIPMAP = 2
      };

      struct CubeMapData
      {
         osg::Vec3d myLastUpdatePos;
         unsigned int myID;
         unsigned int myCurrentUpdateFace;
         CubeMapUpdateState myUpdateState;
         bool myNeedsFullRegen;
      };


   public:

      DtCloudDrawable(DtSilverliningGroup* parent = 0);

      DtCloudDrawable(const DtCloudDrawable& copy,const osg::CopyOp& op);

      virtual ~DtCloudDrawable();
   public:

      META_Object(vrvOsg,DtCloudDrawable)

      virtual void releaseGLObjects(osg::State* state) const;

      virtual void slot_channelDestroyed(DtChannelManager* channelManager, DtChannel* channel);

      void setCrepuscularRays(bool enabled);

      void updateCubeMaps(bool fullRegenerate);
 
      unsigned int getCubeMap(const osg::ref_ptr<const osg::Camera> camera) const;

      unsigned int getPrimaryCubeMap() const;
     
      virtual void drawImplementation(osg::RenderInfo& renderInfo) const;

      void setGeocentricMode(bool mode);

      virtual void cleanupCloudLayer(SilverLining::Atmosphere* atm, unsigned int layerHandle);

   protected:

      void fadeCloudsWithAltitude(double altitudeMSL, SilverLining::CloudLayer * layer);
      void updateCloudAltitudes(const osg::Vec3d& localPosition, SilverLining::Atmosphere *atm);
      
      //helper functions for seting up the virtual program shaders and uniforms.
      void updateShader(osg::Node *node, osg::State& state, SilverLining::Atmosphere *atm) const;
      void updateOpenGLState(osg::State &state, SilverLining::Atmosphere *atm, osg::Camera *cam) const;
      void setIsReflectionUniform(osg::State &state, SilverLining::Atmosphere* atm, bool isReflection) const;

      void connectSingals();

      void initUniforms();

      virtual void disconnectSignals();

      virtual void slot_environmentChanged(const std::string& name);

      bool computeHeightAboveTerrain(const osg::Vec3d& localPosition, double& heightOfGround);
      void updateCloudLayerAltitudes(SilverLining::Atmosphere* atm);

   protected:

      virtual void updateDepthTexture(osg::RenderInfo& renderInfo) const;

      virtual void unbindDepthTexture(osg::RenderInfo& renderInfo) const;

      virtual void updateSoftnessAndSmoothCloudsFromImGui() const;

      virtual CubeMapData* getOrCreateCubeMapData(osg::Camera* camera, const osg::Vec3d& camPos) const;
      
      //variable for keeping the user shader list around so it can be deleted after new shaders are loaded.
      mutable std::vector<unsigned int> myUserShaderVector;

      DtSilverliningGroup* myParent;
      DtDe& myDe;

      bool myCrepuscularRays;
      bool myGeocentricFlag;

      osg::Vec3d myLastHOTUpdatePos;
      bool myForceHOTUpdate;
      double myHOT;
      
      bool mySkipUpdateAltitudes;
      std::map<SilverLining::CloudLayer *, double> myOriginalAltitudesMap;

      typedef std::map<osg::observer_ptr<const osg::Camera>, CubeMapData *> MapCameraToCubeMapData;
      mutable MapCameraToCubeMapData myCubeMapDataMap;
      virtual void flushInvalidCamerasForCubeMap(void);

      mutable unsigned int myMutableLastFrameNum;
      mutable unsigned int myMutablePrimaryCubeMap;

      mutable osg::ref_ptr<osg::Uniform> myMutableSoftnessUniform;
      mutable osg::ref_ptr<osg::Uniform> myMutableInvPersMatrixUniform;
      mutable osg::ref_ptr<osg::Uniform> myMutablePersMatrixUniform;
      mutable osg::ref_ptr<osg::Uniform> myMutableViewportUniform;
      mutable osg::ref_ptr<osg::Uniform> myMutableIsReflectionUniform;
      mutable osg::ref_ptr<osg::Uniform> myMutableViewMatrixInverseUniform;
      mutable osg::ref_ptr<osg::Uniform> myMutableIsSunMoonDiskUniform;
      mutable osg::ref_ptr<osg::Uniform> myMutableIsStarUniform;

      //cached pointer to stateset for this drawable
      osg::ref_ptr<osg::StateSet> myStateSet;
      
      mutable bool myEnableSmoothClouds;
      mutable float mySmoothCloudsDist;
      mutable double myLastImGuiSimTime;

      unsigned long int myNextCameraID;
      typedef std::map< osg::observer_ptr<const osg::Camera>, unsigned long int > MapOsgCamerasToEnvMapCameraIDs;
      MapOsgCamerasToEnvMapCameraIDs myMapOsgCamerasToEnvMapCameraIDs;
      virtual void flushInvalidCamerasForEnvMap(void);
      virtual unsigned long int getOrCreateCameraHandleForEnvMap(const osg::RenderInfo& renderInfo);

      DtSignalConnectionManager myConnections;
   };
}