DtWeatherLightning.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2023 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/Matrixd>
#include <osg/Array>

namespace osg
{
   class RenderInfo;
   class StateSet;
   class State;
}

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


   class DtWeatherLightning;

   typedef DtVirtualBaseClassCreator<DtWeatherLightning> DtWeatherLightningCreator;

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

   class DT_DLL_VRVOSG DtWeatherLightning : public DtVirtualBaseClass
   {
      friend class DtWeatherLightningFactory;

   public:

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

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

      friend DtWeatherLightningCreator;

      virtual ~DtWeatherLightning();

      DtWeatherLightning() = delete;

      DtWeatherLightning(const DtWeatherLightning &other) = delete;

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

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

   public:

      virtual void init();

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

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

      virtual bool cullUpdate(const osg::Vec3d& camPos, const osg::Matrixd& viewMatrixI,
         const Frustum_64& frustum, DtJobSplitter* jobSplitter);

      virtual void draw(DtWeatherLightning::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 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)
            , myVboNormalArray(0)
            , myVboTexCoordArray(0)
            , myVboIndiceArray(0)
            , myIndices(0)
            , myIndicesCount(0)
            , myActivePointCount(0)
         {
            myPoints = new osg::Vec4Array;
            myNormals = new osg::Vec4Array;
            myTexCoords = new osg::Vec2Array;
         }

         osg::ref_ptr<osg::Vec4Array> myPoints;
         osg::ref_ptr<osg::Vec4Array> myNormals;
         osg::ref_ptr<osg::Vec2Array> myTexCoords;
         unsigned short* myIndices;
         unsigned int myIndicesCount;
         unsigned int myActivePointCount;

         DtGlBuffer* myVboPositionArray = nullptr;
         DtGlBuffer* myVboNormalArray = nullptr;
         DtGlBuffer* myVboTexCoordArray = nullptr;
         DtGlBuffer* myVboIndiceArray = nullptr;
      };

      struct LightningFinger
      {
         LightningFinger()
            : myDirection(1, 0, 0)
            , myWidthScale(1.0f)
            , myChildDepth(0)
         {
            // intentional noop
         }

         osg::Vec3 myDirection;
         float myWidthScale;
         int myChildDepth;
         osg::Vec3 myPoints[16];
         std::vector<LightningFinger*> myChildren;
      };

      struct LightningBolt
      {
         LightningBolt()
            : mySortDepth(0)
            , myUnique(0.0f)
            , myAliveTime(0)
            , myTime(0)
            , myStart(0,0,0)
            , myEnd(0,0,0)
            , myLightPosition(0,0,0)
            , myActiveFingers(0)
            , myRootFinger(0)
            , myMeshGroup(0)
            , myVaoManager(0)
            , myMeshDirty(false)
         {
            // intentional noop
         }

         float mySortDepth;
         float myUnique;
         float myAliveTime; // amount of time to stay alive
         float myTime;      // amount of time that has passed
         osg::Vec3 myStart;
         osg::Vec3 myEnd;
         osg::Vec3d myLightPosition;
         LightningFinger myLightningFingerPool[24]; // memory pool
         int myActiveFingers;
         LightningFinger* myRootFinger;
         MeshGroup* myMeshGroup;
         DtGlVaoManager* myVaoManager;
         bool myMeshDirty;
      };

      struct SortDistanceComparator;
      friend struct SortDistanceComparator;

      struct SortDistanceComparator
      {
      public:
         bool operator()(const DtWeatherLightning::LightningBolt* lhs, const DtWeatherLightning::LightningBolt* rhs);
      };

      virtual void initBoltMeshGroup(LightningBolt* bolt);

      virtual void createBolt(const osg::Vec3& start, const osg::Vec3& end);

      virtual void createFingerSegments(LightningBolt* bolt, LightningFinger* finger);

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

      void fillMeshGroupFlashPoint(LightningBolt* bolt);

      virtual void fillMeshGroup(LightningBolt* bolt, LightningFinger* finger);

      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;

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

   protected:

      static void theSortJob(void* data);

   protected:

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

         DtWeatherLightning* myWeatherLightning;
         osg::Vec3 myLocalCameraPos;
      };

      DtDe& myDe;

      bool myEnabled;
      bool myCulled;

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

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

      float myBoltWidth;
      float myIntensity;
      osg::Vec3 myBaseColor;

      // These are mutable because they modified during releaseGLObjects. 
      mutable std::vector<LightningBolt*> myMutableLightningBoltsPool;   // memory pool
      mutable std::vector<LightningBolt*> myMutableLightningBoltsActive; // active list

      SortJobData mySortJobData;
      DtJobSplitterJob mySortJob;

      DtRandomNumberGenerator myRandomNumberGen;
      unsigned int myRandomSeed;

      float myStrikeTimeMin;
      float myStrikeTimeMax;
      float myStrikeTimer;

      DtLight* myLight;
   };
}