DtWeatherPrecipitationShaft.h

Go to the documentation of this file.

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


#pragma once

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

#include <vrvMath/DtCameraFwdDeclare.h>

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

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

#include <matrix/vlVector.h>

#include <osg/Vec3d>
#include <osg/Vec4d>
#include <osg/Array>
#include <osg/Matrixd>
#include <osg/ref_ptr>

namespace osg
{
   class RenderInfo;
   class StateSet;
}

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

   class DtWeatherPrecipitationShaft;

   typedef DtVirtualBaseClassCreator<DtWeatherPrecipitationShaft> DtWeatherPrecipitationShaftCreator;

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


   class DT_DLL_VRVOSG DtWeatherPrecipitationShaft : public DtVirtualBaseClass
   {
      friend DtWeatherPrecipitationShaftCreator;

   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 ~DtWeatherPrecipitationShaft();

      DtWeatherPrecipitationShaft() = delete;

      DtWeatherPrecipitationShaft(const DtWeatherPrecipitationShaft &other) = delete;

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

   protected:
      
      DtWeatherPrecipitationShaft(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 Frustum_64& frustum, DtJobSplitter* jobSplitter);

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

      virtual void draw(DtWeatherPrecipitationShaft::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::Vec3f& localCamPos);

      virtual void setEnabled(bool enabled);

      virtual bool enabled() const;

      virtual bool culled() const;

      virtual void computeBounds(osg::Vec4f& 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;

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

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

         float mySortDepth;
         osg::Vec4f myPosition;
      };

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

      virtual float computeRandomMinMax(float fMin, float fMax);

      virtual void computeSortDepth(const osg::Vec3f& 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;

   protected:

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

      static void theSortJob(void* data);

   protected:

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

         DtWeatherPrecipitationShaft* myWeatherPrecipitationShaft;
         osg::Vec3f 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::Vec3f 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;
   };
}