DtWaterOnScreenEffect.h

Go to the documentation of this file.

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

 
#pragma once

#include <vrvTriton/vrvTriton.h>
#include <matrix/vlVector.h>

#include <vrvOsg/vrvOsg.h> 

#include <vrvPostProcessor/DtPostProcessor.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <osg/Texture2D>
#include <osg/Image>


// The dimension of the grid used to divide the screen into discrete
// locations for water drops.
#define GRID_DIMENSION 200
// The texture size of the normal map used for post processing. This has
// a big impact on performance, so don't make it bigger than necessary.
// Having it kind of low is also useful for blurring the drops a bit and
// giving a cheap depth of field effect on them.
#define TEXSIZE 768

namespace makVrv 
{ 
   class DropParticle;
   class RaindropParticle;
   class SplashParticle;
   class DtWindow;
   class DtObserverObject;

   class DT_DLL_VRVTRITON DtWaterOnScreen : public DtPostProcessor
   {
   public:
      DtWaterOnScreen(DtDe& de, const std::string& postProcessType, bool handles2D);

      virtual ~DtWaterOnScreen();

      void activateRaindrops(bool on);

      void activateSplashes(bool on);

      void activateSpray(bool on);

      void setIsUnderwater(bool underwater);

      void addRainDrop(float x, float y, float radius);

      void addOceanSplash(float intensity);

      void setSplashIntensity(float intensity);

      void setSprayIntensity(float intensity);

      virtual bool update(DtChannel *channel);

      int getNumActiveDrops() const;

      void setWaterOnScreenSize(double size);

      static double waterOnScreenSize();

      class GridCell
      {
      public:
         GridCell();

         DropParticle *drop;
         float affinityForWater;
      };

      void addSplashEffects(const DtObserverObject *observer, bool hasWaveSplashEffect);

      void addSprayEffects(const DtObserverObject *observer, bool hasOceanSprayEffect);

   protected:
      virtual void initialize();

      void clearNormalMap();

      void updateAndDrawDrops(double elapsedTime);

      void addRaindrops(double time, float heading, float observerVelocity);

      void addSpray(double time, float heading);

      void clearDrops();

      void reset();

      void setActiveStatus();

      void slot_windowRemoved(DtWindow* window);

      void slot_waterOnScreenSizeChanged(double value);

      osg::ref_ptr<osg::Texture2D> myNormalMap;
      osg::ref_ptr<osg::Image> myNormalImage;
      DtDe& myDe;

      double myLastUpdateTime;
      double myLastDropEmissionTime, myLastSprayEmissionTime;
      
      bool myRaindropsActiveFlag, mySplashesActiveFlag, mySprayActiveFlag;
      bool myActiveFlag, myUnderwaterFlag;

      float mySplashIntensity, mySprayIntensity;

      int myNumActiveDrops;

      static double myWaterOnScreenSize;

      GridCell myGrid[GRID_DIMENSION][GRID_DIMENSION];

      unsigned char myNormalMapClearData[TEXSIZE*TEXSIZE*4];
      bool myNormalMapClearDataInitialized;
      unsigned char myNormalImageData[TEXSIZE*TEXSIZE*4];

      DtSignalConnectionManager mySignals;
   };

   // 
   // Creator
   //

   class DT_DLL_VRVTRITON DtWaterOnScreenCreator 
       : public DtPostProcessorCreator
   {
   public:
       friend class DtPostProcessManager;

       DtWaterOnScreenCreator();

       virtual ~DtWaterOnScreenCreator();

   protected:
       virtual DtPostProcessor* create(DtDe& de, const std::string& postProcessType);
   };
}