DtWaterOnScreenEffect.h

Go to the documentation of this file.

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

#pragma once


#include <vrvPostProcessor/vrvPostProcessor.h>

#include <vrvPostProcessor/DtPostProcessor.h>
#include <vrvPostProcessor/DtGridCell.h>
#include <vrvPostProcessor/DtWaterOnScreenDefines.h>
#include <vrvPostProcessor/DtWaterOnScreenDrawable.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvMath/DtVector4.h>

#include <matrix/vlVector.h>

#include <osg/ref_ptr>

namespace makVrv
{
   class DtDropParticle;
   class DtRaindropParticle;
   class DtSplashParticle;
   class DtWindow;
   class DtObserverObject;

   class DtGlTexture;
   class DtGlProgram;
   class DtGlBuffer;

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

      virtual ~DtWaterOnScreen();
   private:
      DtWaterOnScreen() = delete;

      DtWaterOnScreen(const DtWaterOnScreen&) = delete;

      DtWaterOnScreen& operator=(const DtWaterOnScreen&) = delete;
   public:
      virtual void activateRaindrops(bool on);

      virtual void activateSplashes(bool on);

      virtual void activateSpray(bool on);

      virtual void setIsUnderwater(bool underwater);

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

      virtual void addOceanSplash(float intensity);

      virtual void setSplashIntensity(float intensity);

      virtual void setSprayIntensity(float intensity);

      virtual bool update(DtChannel *channel);

      virtual int numActiveDrops() const;

      virtual void setWaterOnScreenSize(double size);

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

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

      virtual bool prepForDrawableRender();

   public:
      static double waterOnScreenSize();

   protected:
      virtual void initialize();

      virtual void clearNormalMap();

      virtual void updateDrops(double elapsedTime);

      virtual bool drawDrops();

      virtual bool finalizeNormalMap();

      virtual void addRaindrops(double time, float heading, float observerVelocity, const DtVector& observerLocation);

      virtual void addSpray(double time, float heading);

      virtual void clearDrops();

      virtual void reset();

      virtual void setActiveStatus();

      virtual void slot_waterOnScreenSizeChanged(double value);
      virtual void slot_reloadShaders();

      virtual void releaseGLObjects() override;

      virtual void cleanupGpuMemory(void);

      virtual void createNormalMapIfNecessary(void);

      virtual void createNormalMapCombineProgramIfNecessary(void);

      virtual void createNormalMapFinalizeProgramIfNecessary(void);

      virtual void initZeroNormals(void);

   protected:
      double myLastUpdateTime;
      double myLastDropEmissionTime, myLastSprayEmissionTime;

      bool myRaindropsActiveFlag, mySplashesActiveFlag, mySprayActiveFlag;
      bool myActiveFlag, myUnderwaterFlag;

      float mySplashIntensity, mySprayIntensity;

      int myNumActiveDrops;

      DtGridCell myGrid[GRID_DIMENSION][GRID_DIMENSION];

      DtGlProgram* myNormalMapCombineProgram;
      bool myNormalMapCombineProgramTriedOnce;

      DtGlProgram* myNormalMapFinalizeProgram;
      bool myNormalMapFinalizeProgramTriedOnce;

      DtGlTexture* myNormalMap;

      DtGlBuffer* myNormalMapBuffer;

      DtGlBuffer* myPrecomputedDropletNormalsBuffer;
      bool myPrecomputedDropletNormalsBufferDirty;

      DtGlBuffer* myPrecomputedSplashNormalsBuffer;
      bool myPrecomputedSplashNormalsBufferDirty;

      struct GridCell
      {
         Vector4_32 x_y_radius_valid;
         Vector4_32 type_intensity_unused;
      };

      GridCell myGridCells[GRID_DIMENSION][GRID_DIMENSION];

      DtGlBuffer* myCellsBuffer;

      DtVector4<unsigned int> myZeroNormals[TEXSIZE][TEXSIZE];

      osg::ref_ptr<DtWaterOnScreenDrawable> myWaterOnScreenDrawable;

      bool myDropsStagingDirty;
      bool myNormalMapDirty;

   public:
      static double theWaterOnScreenSize;
   };

   // 
   // Creator
   //

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

      DtWaterOnScreenCreator();

      virtual ~DtWaterOnScreenCreator();

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