DtWeatherEffect.h

Go to the documentation of this file.

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


#pragma once

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

#include <vrvCore/DtJobSplitter.h>

#include <vrvUtil/DtVirtualBaseClassCreator.h>
#include <vrvUtil/DtRandomNumberGenerator.h>

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


namespace makVrv
{
   // Forward declarations.
   class DtWeatherArea;
   class DtWeatherEffectDrawable;
   class DtWeatherEffectsObject;
   class DtIntersector;
   class DtGlBuffer;

   enum DtWeatherEffectType
   {
      EffectTypePrecipitation = 0,
      EffectTypeParticle
   };


   class DtWeatherEffect;

   typedef DtVirtualBaseClassCreator<DtWeatherEffect, const int&, const float&, const float&
      , const DtWeatherEffectType&, const unsigned int&> DtWeatherEffectCreator;

   template <>
   inline const char* creatorTypeName<DtWeatherEffect>(void) { return "DtWeatherEffectCreator"; }

   class DT_DLL_VRVOSG DtWeatherEffect
   {
   public:

      struct DrawData
      {
         DrawData()
            : myRenderInfo(0)
            , myWeatherEffectsObject(0)
            , myCamPos(0, 0, 0)
            , myCamMove(0, 0, 0)
            , myIsGeoCentric(false)
            , myNearClip(1.0f)
            , myParametersUnfmLoc(0)
            , mySoftnessUnfmLoc(0)
            , myDepthProxyUnfmLoc(0)
            , mySurfaceUnfmLoc(0)
            , mySurfaceProjUnfmLoc(0)
            , myAdditiveBlend(false)
            , myStateDirty(true)
            , myAppliedHeightMap(false)
            , myDrawable(0)
            , mySurfaceHeights(0)
            , mySurfaceHeightCount(0)
            , mySurfaceBoundsX(1)
            , mySurfaceBoundsY(1)
            , mySurfaceCornerRadius(1)
            , mySurfaceAltitude(0)
            , myElevationMin(0)
            , myElevationRange(100000.0f)
         {
            // intentional nop
         }

         osg::RenderInfo* myRenderInfo;
         DtWeatherEffectsObject* myWeatherEffectsObject;
         osg::Vec3d myCamPos;
         osg::Vec3d myCamMove;
         bool myIsGeoCentric;
         float myNearClip;
         GLint myParametersUnfmLoc;
         GLint mySoftnessUnfmLoc;
         GLint myDepthProxyUnfmLoc;
         GLint mySurfaceUnfmLoc;
         GLint mySurfaceProjUnfmLoc;
         bool myAdditiveBlend;
         bool myStateDirty;
         bool myAppliedHeightMap;
         const DtWeatherEffectDrawable* myDrawable;
         const unsigned int* mySurfaceHeights;
         int mySurfaceHeightCount;
         float mySurfaceBoundsX;
         float mySurfaceBoundsY;
         float mySurfaceCornerRadius;
         float mySurfaceAltitude;
         osg::Matrixf mySurfaceMatrix;
         float myElevationMin;
         float myElevationRange;
      };

  

      enum SurfaceHitType
      {
         SurfaceHitTypeNone = 0,
         SurfaceHitTypeHail,
         SurfaceHitTypeWindBlown,
      };


      DtWeatherEffect(makVrv::DtDe& de, const int& particleCount, const float& particleSize, const float& radius
         ,const DtWeatherEffectType& type, const unsigned int& randomSeed);

      virtual ~DtWeatherEffect();

   private:

      DtWeatherEffect() = delete;

      DtWeatherEffect(const DtWeatherEffect &other) = delete;

      DtWeatherEffect &operator=(const DtWeatherEffect &other) = delete;

   public:

      virtual void init(int particleCount, float particleSize, float radius, DtWeatherEffectType type, unsigned int randomSeed);

      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, float cullFade = 1.0f) const;

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

      virtual void setSurfaceHitType(SurfaceHitType type);

      virtual void setSurfaceHitOffset(float offset);

      virtual void setSurfaceHitMaxSlope(float degrees);

      virtual void setWindBlownParameters(int spawnCount, float minSpeed, float maxSpeed, float minTime, float maxTime);

      virtual void setWind(float windDirectionRad, float windSpeedMps);

      virtual void setWindSpeedMultiplier(float multiplier);

      virtual void setWindLiftMultiplier(float multiplier);

      virtual void setWindTurbulence(float multiplier);

      virtual void setWindVariation(float minWind, float maxWind);

      virtual void setScaleAnimation(float minX, float maxX, float minY, float maxY, float time);

      virtual void setStreak(float multiplier);

      virtual void setCameraStreakEnable(bool enable);

      virtual void setStreakAdjustmentEnable(bool enable);

      virtual void setOrientFlat(bool enable);

      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 setTextureCoordAnimationPerWind(float multMin, float multMax, float windMin, float windMax);

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

      virtual void setBaseColor(const osg::Vec3& color);

      virtual void setAdditiveBlend(bool enable);

      virtual bool additiveBlend() const;

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

      virtual void setInitRotationVariation(float rotationDeg);

      virtual void setRotationVelocity(float velDeg);

      virtual float radius() const;

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

      virtual void setTextureCoordinateAnimation(float dirSpeedU, float dirSpeedV, float scale0, float scale1);

      virtual void setTexturePatternChannelMix(float mix0, float mix1);

      virtual void setDepthSoftness(float softness);

      virtual float depthSoftness() const;

      virtual void setDepthProximity(float startFade, float fadeEnd, float mix);

      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);

      virtual void setClampToSurface(bool enable);

      virtual bool clampToSurface() const;

      virtual void setGravity(const osg::Vec3& gravity);

      virtual void setRadiusFading(float fadeInStart, float fadeInEnd, float fadeOutStart, float fadeOutEnd);

   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;

         DtGlBuffer* myVboPositionArray = nullptr;
         DtGlBuffer* myVboMoveArray = nullptr;
         DtGlBuffer* myVboTexCoords0Array = nullptr;
      };

      struct Particle
      {
         Particle()
            : myParent(0)
            , myChild(0)
            , mySortDepth(0)
            , myPosition(0, 0, 0, 0)
            , myMove(0, 0, 0, 1)
            , myVelocity(0, 0, 0)
            , myLifeTime(0.0f)
            , myLifeTimeInit(1.0f)
            , myUsePhysics(1)
            , myFadeCurve(0)
         {
            //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;
         float myLifeTime; // current life time left
         float myLifeTimeInit; // initial life time
         unsigned char myUsePhysics; // note: not a bool to save memory
         unsigned char myFadeCurve;
      };

      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 updateWindBlownSurfaceHit(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,
         const unsigned char usePhysics);

      void spawnWindBlownParticle(const osg::Vec3d& position,
         const osg::Vec3& normal, float windRandom, float cosAng);

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

      virtual bool updateRandomSeed( double currentTime );

      virtual void setRandomSeedSyncTimeInterval( unsigned int intervalInMs );

      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;

   protected:

      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;

      DtWeatherEffectType myEffectType;
      SurfaceHitType mySurfaceHitType;
      float mySurfaceHitOffset;
      float mySurfaceHitMaxSlope;
      float mySurfaceHitTimer;
      unsigned int myRandomSeed;
      osg::Vec3 myScroll;
      float myRadius;
      float myWindDirectionRad;
      float myWindSpeedMps;
      float myWindSpeedMultiplier;
      float myWindLiftMultiplier;
      float myWindTurbulence;
      float myWindMin;
      float myWindMax;
      float myDragCoefficient;
      osg::Vec3 myVelocity;
      float myInitRotationRad;
      float myRotationVelocity;
      float myEffectFade;
      float myIntensity;
      BlendData myFadeByIntensity;
      BlendData myFadeByWind;
      BlendData myTexCoordAnimSpeedByWind;
      BlendData myParticlesByIntensity;
      float myParticleSize;
      osg::Vec3 myBaseColor;
      bool myAdditiveBlend;
      osg::ref_ptr<osg::BlendFunc> myBlendFunc;
      float myStreak;
      float myStreakAdjustment;
      bool myStreakAdjustmentEnable;
      bool myCameraStreak;
      float myScaleAnimMinX; // particle width axis shrink/grow
      float myScaleAnimMaxX;
      float myScaleAnimMinY; // particle height axis shrink/grow
      float myScaleAnimMaxY;
      float myScaleSpeed;
      float myTextureAtlasCols;
      float myTextureAtlasRows;
      float myTextureAtlasCol;
      float myTextureAtlasRow;
      float myTexCoordAnimDirSpeedU;
      float myTexCoordAnimDirSpeedV;
      float myTexCoordAnimScale0;
      float myTexCoordAnimScale1;
      float myTexCoordAnimDirOffsetU;
      float myTexCoordAnimDirOffsetV;
      float myTexturePatternMix0;
      float myTexturePatternMix1;
      float myDepthSoftness;
      float myDepthProximityMix;
      float myDepthProximityStart;
      float myDepthProximityRange;
      float myDepthProximityInvRange;
      bool mySortEnable;
      bool myClampToSurface;
      bool myOrientFlat;
      osg::Vec3 myGravity;
      float myRadiusFadeInStart;
      float myRadiusFadeInFalloff;
      float myRadiusFadeOutStart;
      float myRadiusFadeOutFalloff;

      int myWindBlownSpawnCount; // for surface hit wind blown particles
      float myWindBlownMinSpeed;
      float myWindBlownMaxSpeed;
      float myWindBlownMinTime;
      float myWindBlownMaxTime;

      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;
      unsigned int mySeedSyncInterval;
      unsigned long myNextSyncTime;

      DtIntersector* myIntersector = nullptr;
   };
}