DtWeatherEffect.h

Go to the documentation of this file.

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


#pragma once

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

#include <vrvUtil/DtJobSplitter.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtRandomNumberGenerator.h>

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


namespace makVrv
{
   // Forward declarations.
   class DtWeatherEffectDrawable;


   class DT_DLL_VRVOSG DtWeatherEffect
   {
   public:

      struct DrawData
      {
         DrawData()
            : myRenderInfo(0)
            , myCamPos(0, 0, 0)
            , myCamMove(0, 0, 0)
            , myNearClip(1.0f)
            , myParametersUnfmLoc(0)
            , mySoftnessUnfmLoc(0)
            , myAdditiveBlend(false)
            , myStateDirty(true)
            , myDrawable(0)
         {
            // intentional nop
         }

         osg::RenderInfo* myRenderInfo;
         osg::Vec3d myCamPos;
         osg::Vec3d myCamMove;
         float myNearClip;
         GLint myParametersUnfmLoc;
         GLint mySoftnessUnfmLoc;
         bool myAdditiveBlend;
         bool myStateDirty;
         const DtWeatherEffectDrawable* myDrawable;
      };

      enum EffectType
      {
         EffectTypePrecipitation = 0,
         EffectTypeParticle
      };

      enum SurfaceHitType
      {
         SurfaceHitTypeNone = 0,
         SurfaceHitTypeHail
      };


      DtWeatherEffect(makVrv::DtDe& de);

      virtual ~DtWeatherEffect();

   private:

      DtWeatherEffect();

      DtWeatherEffect(const DtWeatherEffect &other);

      DtWeatherEffect &operator=(const DtWeatherEffect &other);

   public:

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

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

      virtual void simulationUpdate(float timeStep, double currentTime, DtJobSplitter* jobSplitter);

      virtual void postSimulationUpdate(float timeStep, double currentTime);

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

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

      virtual void setSurfaceHitType(SurfaceHitType type);

      virtual void setWind(float windDirectionRad, float windSpeedMps);

      virtual void setWindSpeedMultiplier(float multiplier);

      virtual void setWindLiftMultiplier(float multiplier);

      virtual void setWindTurbulence(float multiplier);

      virtual void setStreak(float multiplier);

      virtual void setCameraStreakEnable(bool enable);

      virtual void setEffectFade(float fade);

      virtual void setIntensity(float intensity);

      virtual void setFadePerIntensity(float fadeMin, float fadeMax, float intensityMin, float intensityMax);

      virtual void setFadePerWind(float fadeMin, float fadeMax, float windMin, float windMax);

      virtual void setParticlesPerIntensity(float percentMin, float percentMax, float intensityMin, float intensityMax);

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

      virtual void setAdditiveBlend(bool enable);

      virtual bool additiveBlend() const;

      virtual void setVelocity(float x, float y, float z);

      virtual void setInitRotationVariation(float rotationDeg);

      virtual float radius() const;

      virtual void setTextureAtlasCell(unsigned char numColumns, unsigned char numRows, unsigned char col, unsigned char row);

      virtual void setDepthSoftness(float softness);

      virtual float depthSoftness() const;

      virtual void setDragCoefficient(float coefficient);

      virtual float dragCoefficient() const;

      virtual void setSortEnable(bool enable);

      virtual bool sortEnable() const;

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

   protected:

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

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

         unsigned int myVboPositionArray;
         unsigned int myVboMoveArray;
         unsigned int myVboTexCoords0Array;
      };

      struct Particle
      {
         Particle()
            : myParent(0)
            , myChild(0)
            , mySortDepth(0)
            , myPosition(0, 0, 0, 0)
            , myMove(0, 0, 0, 1)
            , myVelocity(0, 0, 0)
            , myUsePhysics(true)
            , myLifeTime(0.0f)
            , myLifeTimeInit(1.0f)
         {
            //intentional nop
         }

         Particle* myParent; // next particle in linked list
         Particle* myChild;  // previous particle in link list
         float mySortDepth;
         osg::Vec4 myPosition;
         osg::Vec4 myMove;
         osg::Vec3 myVelocity;
         bool myUsePhysics;
         float myLifeTime; // current life time left
         float myLifeTimeInit; // initial life time
      };

      struct BlendData
      {
         BlendData()
            : myValueMin(0)
            , myValueMax(1)
            , myBlendMin(0)
            , myBlendMax(1)
         {
            //intentional nop
         }

         float myValueMin; // the output value at the min blend
         float myValueMax; // the output value at the max blend
         float myBlendMin; // < this value output is 0
         float myBlendMax; // >= this value, output is myValueMax 
      };

      virtual void runSimulationUpdateJob(float timeStep, double currentTime);

      virtual void updateHailSurfaceHit(float timeStep);

      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 simulatePrecipitationParticles(float timeStep, double currentTime);

      virtual void simulateParticles(float timeStep, double currentTime, osg::Vec3d& basisPosChange);

      // non-virtual for maximum inner loop performance.

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

      Particle* getFreeParticle(void);

      void freeParticle(Particle* particle);

      void spawnHailParticle(const osg::Vec3d& position, const osg::Vec3& normal, bool usePhysics);

      const osg::Vec3 crossProduct(const osg::Vec3& v0, const osg::Vec3& v1);

      float computeRandomMinMax(float fMin, float fMax);

      void computeRandomPointInRadius(osg::Vec2& point, float radius);

      bool clampPosition(osg::Vec3d& position, osg::Vec3& normal, const osg::Vec3& up);

      virtual float computeBlendControl(const BlendData& data, float blendPos) const;

   private:

      static void theSimulationUpdateJob(void* data);
      
      static int theSortBackToFront(const void* arg0, const void* arg1);

      static void theSortJob(void* data);

   protected:
  
      struct SimulationUpdateJobData
      {
         SimulationUpdateJobData()
            : myEffect(0)
            , myTimeStep(0)
            , myCurrentTime(0)
         {
            //intentional nop
         }

         DtWeatherEffect* myEffect;
         float myTimeStep;
         double myCurrentTime;
      };

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

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

      DtDe& myDe;

      osg::Matrixd myBasisRot;
      osg::Vec3d myBasisPos;
      osg::Vec3d myLastBasisPos;
      bool myBasisDirty;

      EffectType myEffectType;
      SurfaceHitType mySurfaceHitType;
      float mySurfaceHitTimer;
      osg::Vec3 myScroll;
      float myRadius;
      float myWindDirectionRad;
      float myWindSpeedMps;
      float myWindSpeedMultiplier;
      float myWindLiftMultiplier;
      float myWindTurbulence;
      float myDragCoefficient;
      osg::Vec3 myVelocity;
      float myInitRotationRad;
      float myEffectFade;
      float myIntensity;
      BlendData myFadeByIntensity;
      BlendData myFadeByWind;
      BlendData myParticlesByIntensity;
      float myParticleSize;
      osg::Vec3 myColorMult;
      bool myAdditiveBlend;
      osg::ref_ptr<osg::BlendFunc> myBlendFunc;
      float myStreak;
      float myStreakAdjustment;
      bool myCameraStreak;
      float myTextureAtlasCols;
      float myTextureAtlasRows;
      float myTextureAtlasCol;
      float myTextureAtlasRow;
      float myDepthSoftness;
      bool mySortEnable;

      MeshGroup* myMeshGroup;
      DtGlVaoManager* myVaoManager;

      Particle* myParticlesMemoryPool; // the array of all particles
      int myParticleMemoryPoolCount;   // the maximum number of particles

      Particle* myParticlesFree;   // the head of the free particle list
      Particle* myParticlesActive; // the head of the active particle list
      int myParticleActiveCount;   // current active amount of particles

      Particle** myRenderList;   // particle render list array
      int myRenderParticleCount; // number of particles active in the render list array

      SimulationUpdateJobData mySimulationUpdateJobData;
      DtJobSplitterJob mySimulationUpdateJob;

      SortJobData mySortJobData;
      DtJobSplitterJob mySortJob;

      DtRandomNumberGenerator myRandomNumberGen;
   };


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

      virtual ~DtWeatherEffectCreator();

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

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

      static DtWeatherEffectCreator& instance(DtDe& de);

      static const std::string& theClassName();

   protected:
      DtDe& myDe;
   };
}