DtGroundFogEffect.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/DtGlVaoManager.h>
#include <vrvOsg/vrvOsg.h>

#include <vrvCore/DtJobSplitter.h>

#include <vrvUtil/DtVirtualBaseClass.h>

#include <osg/RenderInfo>
#include <osg/Vec3d>


namespace makVrv
{
   // Forward declarations.
   class DtWeatherAreaGroup;


   class DT_DLL_VRVOSG DtGroundFogEffect
   {
   public:

      struct DrawData
      {
         DrawData()
            : myRenderInfo(0)
            , myCamPos(0, 0, 0)
            , myParametersUnfmLoc(0)
            , mySoftnessUnfmLoc(0)
            , myWindDirectionRad(0)
            , myWindSpeedMps(0)
            , myWeatherAreaGroup(0)
            , myState(0)
         {
            // intentional nop
         }

         osg::RenderInfo* myRenderInfo;
         osg::Vec3d myCamPos;
         GLint myParametersUnfmLoc;
         GLint mySoftnessUnfmLoc;
         float myWindDirectionRad;
         float myWindSpeedMps;
         const DtWeatherAreaGroup* myWeatherAreaGroup;
         osg::StateSet* myState;
      };

      DtGroundFogEffect(makVrv::DtDe& de);

      virtual ~DtGroundFogEffect();

   private:

      DtGroundFogEffect();

      DtGroundFogEffect(const DtGroundFogEffect &other);

      DtGroundFogEffect &operator=(const DtGroundFogEffect &other);

   public:

      // \param particleCount The maximum number of particles to simulate.
      // \param particleSize The base particle size.
      // \param radius The effect radius.
      virtual void init(int particleCount, float particleSize, float radius);

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

      virtual void draw(DtGroundFogEffect::DrawData& drawData, const osg::Vec3& baseColor) const;

      virtual void cullUpdate(const osg::Vec3d& camPos, DtJobSplitter* jobSplitter);

      virtual void setEnable(bool enable);

      virtual void setWind(float windDirectionRad, float windSpeedMps);

      virtual void setWindSpeedMultiplier(float multiplier);

      virtual void setWindLiftMultiplier(float multiplier);

      virtual void setWindTurbulence(float multiplier);

      virtual void setDensity(float density);

      virtual void setEffectFade(float fade);

      virtual void setIntensityPerWindRamp(float start, float end);

      virtual float computeIntensityPerWind();

      virtual void setBasisRotation(const osg::Matrixd& rotation);

      virtual void setColorMult(float r, float g, float b);

      virtual float radius() const;

      virtual void runSort(const osg::Vec3& localCamPos);

   protected:

      struct MeshGroup
      {
         MeshGroup()
            : myVboPositionArray(0)
            , myVboTexCoords0Array(0)
         {
            myPoints = new osg::Vec4Array;
            myTexCoords0 = new osg::Vec2Array;
         }

         osg::ref_ptr<osg::Vec4Array> myPoints;
         osg::ref_ptr<osg::Vec2Array> myTexCoords0;

         unsigned int myVboPositionArray;
         unsigned int myVboTexCoords0Array;
      };

      struct Particle
      {
         Particle()
            : mySortDepth(0)
            , myPosition(0, 0, 0, 0)
         {
            //intentional nop
         }

         float mySortDepth;
         osg::Vec4 myPosition;
      };

      virtual void connectSignals();

      virtual void disconnectSignals();

      virtual void slot_simulationUpdate();

      virtual void computeSortDepth(const osg::Vec3& reference);

      virtual void fillSortedParticles();

      virtual bool bindMeshGroupData(MeshGroup* meshGroup, osg::RenderInfo& renderInfo) const;

      virtual bool bindDynamicMeshGroupData(MeshGroup* meshGroup, osg::RenderInfo& renderInfo) const;

      virtual bool bindVaoToMeshGroup(GLuint vao, MeshGroup* meshGroup, osg::RenderInfo& renderInfo) const;

      virtual void simulateParticles(float timeStep, double currentTime);

      // non-virtual for maximum inner loop performance.

      void wrapPosition(float& posX, float& posY, float& posZ);

   private:
      
      static int theSortBackToFront(const void* arg0, const void* arg1);

      static void theSortJob(void* data);

   protected:
  
      struct SortJobData
      {
         SortJobData()
            : myEffect(0)
            , myCameraPos(0, 0, 0)
         {
            //intentional nop
         }

         DtGroundFogEffect* myEffect;
         osg::Vec3 myCameraPos;
      };

      DtDe& myDe;

      osg::Matrixd myBasisRot;

      bool myEnable;
      osg::Vec3 myScroll;
      float myRadius;
      float myWindDirectionRad;
      float myWindSpeedMps;
      float myWindSpeedMultiplier;
      float myWindLiftMultiplier;
      float myWindTurbulence;
      double myLastTime;
      float myEffectFade;
      float myParticleSize;
      osg::Vec3 myColorMult;
      float mfIntensityPerWindStart;
      float mfIntensityPerWindEnd;
      float myDensity;

      MeshGroup* myMeshGroup;
      DtGlVaoManager* myVaoManager;

      Particle* myParticles;
      int myParticleCount;

      SortJobData mySortJobData;
      DtJobSplitterJob mySortJob;
   };


   class DT_DLL_VRVOSG DtGroundFogEffectCreator : public DtVirtualBaseClass
   {
   public:
      DtGroundFogEffectCreator(DtDe &de);

      virtual ~DtGroundFogEffectCreator();

   private:
      DtGroundFogEffectCreator(const DtGroundFogEffectCreator& other);
      DtGroundFogEffectCreator &operator=(const DtGroundFogEffectCreator& other);

   public:
      // \param particleCount The maximum number of particles to simulate.
      // \param particleSize The base particle size.
      // \param radius The effect radius.
      virtual DtGroundFogEffect* create(int particleCount, float particleSize, float radius) const;

      static DtGroundFogEffectCreator& instance(DtDe& de);

      static const std::string& theClassName();

   protected:
      DtDe& myDe;
   };
}