DtWeatherRainShaft.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/DtDe.h>
#include <vrvCore/DtJobSplitter.h>

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

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

#include <matrix/vlVector.h>


namespace makVrv
{
   // Forward declarations.
   class DtJobSplitter;
   class DtWeatherArea;
   class DtWeatherAreaGroup;
   class DtWeatherRainShaftFactory;

   class DT_DLL_VRVOSG DtWeatherRainShaft : public DtVirtualBaseClass
   {
      friend class DtWeatherRainShaftFactory;

   public:

      struct DrawData
      {
         DrawData()
            : myRenderInfo(0)
            , myCamPos(0, 0, 0)
            , myParametersUnfmLoc(0)
            , myTransformUnfmLoc(0)
            , myBoxUnfmLoc(0)
            , myWeatherAreaGroup(0)
            , myState(0)
         {
            // intentional nop
         }

         osg::RenderInfo* myRenderInfo;
         osg::Vec3d myCamPos;
         osg::Matrixd myViewMatrix;
         GLint myParametersUnfmLoc;
         GLint myTransformUnfmLoc;
         GLint myBoxUnfmLoc;
         const DtWeatherAreaGroup* myWeatherAreaGroup;
         osg::StateSet* myState;
      };

      virtual ~DtWeatherRainShaft();

      DtWeatherRainShaft() = delete;

      DtWeatherRainShaft(const DtWeatherRainShaft &other) = delete;

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

   protected:
      
      DtWeatherRainShaft(makVrv::DtDe& de);

   public:

      virtual void init();

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

      virtual bool cullUpdate(const osg::Vec3d& camPos, const osg::Matrixd& viewMatrixI,
         const std::vector<osg::Vec4d>& cullingPlanes, DtJobSplitter* jobSplitter);

      virtual bool isPositionAboveArea(const osg::Vec3d& position);

      virtual void draw(DtWeatherRainShaft::DrawData& drawData);

      virtual void setBounds(const DtVector& bounds, float cornerRadius);

      virtual void setTransform(const osg::Vec3d& position, const osg::Matrixd& rotation);

      virtual void setIntensity(const float intensity);

      virtual void setBaseColor(const DtVector& color);

      virtual void setWind(const float windDirectionRad, const float windSpeedMps);

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

      virtual void setEnabled(bool enabled);

      virtual bool enabled() const;

      virtual bool culled() const;

      virtual void computeBounds(osg::Vec4& bounds, osg::Vec3d& position, osg::Matrixd& rotation) const;

   protected:

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

         osg::ref_ptr<osg::Vec4Array> myPoints;
         osg::ref_ptr<osg::Vec2Array> myTexCoords0;
         unsigned short* myIndices;
         unsigned int myIndicesCount;

         unsigned int myVboPositionArray;
         unsigned int myVboTexCoords0Array;
         unsigned int myVboIndicesArray;
      };

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

         float mySortDepth;
         osg::Vec4 myPosition;
      };

      virtual bool positionInBounds2D(const float x, const float y, const osg::Vec3& bounds);

      virtual float computeRandomMinMax(float fMin, float fMax);

      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 bool isSphereVisible(const std::vector<osg::Vec4d>& planes, const osg::Vec3d& center, double radius) const;

   protected:

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

      static void theSortJob(void* data);

   protected:

      struct SortJobData
      {
         SortJobData()
            : myWeatherRainShaft(0)
            , myLocalCameraPos(0, 0, 0)
         {
            //intentional nop
         }

         DtWeatherRainShaft* myWeatherRainShaft;
         osg::Vec3 myLocalCameraPos;
      };

      DtDe& myDe;

      bool myEnabled;
      bool myCulled;

      MeshGroup* myMeshGroup;
      DtGlVaoManager* myVaoManager;

      osg::Vec3d myPosition;
      osg::Matrixd myRotation;

      float myBoundsX;
      float myBoundsY;
      float myBoundsZ;
      float myBoundsCornerRadius;

      float myParticleWidth;

      float myIntensity;
      osg::Vec3 myBaseColor;

      Particle* myParticles;    // memory pool of particles
      int myParticlePoolCount;  // the number of particles in the memory pool
      int myParticleActiveCount; // number of active particles

      SortJobData mySortJobData;
      DtJobSplitterJob mySortJob;

      DtRandomNumberGenerator myRandomNumberGen;
      unsigned int myRandomSeed;

      float myWindDirectionRad;
      float myWindSpeedMps;
   };



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

      virtual ~DtWeatherRainShaftFactory();

      DtWeatherRainShaftFactory() = delete;

      DtWeatherRainShaftFactory(const DtWeatherRainShaftFactory &other) = delete;

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

      static DtWeatherRainShaftFactory& instance(DtDe& de);

      static const std::string& theClassName();

      virtual DtWeatherRainShaft* create() const;

   protected:

      DtDe& myDe;
   };

}