DtGroundFogPatchArea.h

Go to the documentation of this file.

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


#pragma once

#include <osg/Camera>
#include <osg/Drawable>

#include <vrvCore/DtDe.h>

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

#include <matrix/vlVector.h>

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


namespace makVrv
{
   // Forward declarations.
   class DtGroundFogPatch;
   class DtJobSplitter;
   class DtWeatherAreaGroup;


   class DT_DLL_VRVOSG DtGroundFogPatchArea
   {
   public:

      enum AreaType
      {
         AreaTypePatchyGroundFog,
         AreaTypeSandstorm
      };

      struct DrawData
      {
         DrawData() 
            : myRenderInfo(0)
            , myCamPos(0, 0, 0)
            , myGroundFogUnfmLoc(0)
            , myInstanceParamsUnfmLoc(0)
            , myInstanceMatrixUnfmLoc(0)
            , myPatternedUnfmLoc(0)
            , mySkeletonUnfmLoc(0)
            , mySoftnessUnfmLoc(0)
            , myPatternSize(512.0f)
            , myWindDirectionRad(0)
            , myWindSpeedMps(0)
            , myWeatherAreaGroup(0)
            , myState(0)
         {
            // intentional nop
         }

         osg::RenderInfo* myRenderInfo;
         osg::Vec3d myCamPos;
         GLint myGroundFogUnfmLoc;
         GLint myInstanceParamsUnfmLoc;
         GLint myInstanceMatrixUnfmLoc;
         GLint myPatternedUnfmLoc;
         GLint mySkeletonUnfmLoc;
         GLint mySoftnessUnfmLoc;
         float myPatternSize;
         float myWindDirectionRad;
         float myWindSpeedMps;
         const DtWeatherAreaGroup* myWeatherAreaGroup;
         osg::StateSet* myState;
      };

      DtGroundFogPatchArea(makVrv::DtDe& de);

      virtual ~DtGroundFogPatchArea();

   private:

      DtGroundFogPatchArea();

      DtGroundFogPatchArea(const DtGroundFogPatchArea &other);

      DtGroundFogPatchArea &operator=(const DtGroundFogPatchArea &other);

   public:

      virtual void init(float worldSize, float thickness);

      virtual void addEffect(DtGroundFogEffect* effect);

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

      virtual void releaseFogEffectGLObjects(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 shouldDrawFogPatches();

      virtual void drawFogPatches(DtGroundFogPatchArea::DrawData& drawData);

      virtual void drawFogEffects(DtGroundFogEffect::DrawData& drawData);

      virtual void setDensity(float density);

      virtual float density() const;

      virtual void setTransform(const DtVector& position, float orientation, bool relativeToCamera = false);

      virtual void computeWorldTransform(osg::Vec3d& position, osg::Matrixf& rotation) const;

      virtual void setEnabled(bool enabled);

      virtual bool enabled() const;

      virtual void setClampingEnabled(bool enabled);

      virtual bool clampingEnabled() const;

      virtual float worldSize() const;

      virtual float computeParticleSize() const;

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

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

      virtual void setBaseColor(float red, float green, float blue);

      virtual void setParticleSizeVariation(float variation);

      virtual void setPatternedLook(bool patternedEnable);

      virtual void setAreaType(DtGroundFogPatchArea::AreaType areaType);

      virtual DtGroundFogPatchArea::AreaType areaType() const;

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

   protected:

      struct MeshGroup
      {
         MeshGroup()
            : myVboPositionArray(0)
            , myVboTexCoords0Array(0)
            , myVboBonesArray(0)
            , myVboWeightsArray(0)
         {
            myPoints = new osg::Vec3Array;
            myTexCoords0 = new osg::Vec2Array;
            myBones = new osg::Vec4Array;
            myWeights = new osg::Vec4Array;
         }

         osg::ref_ptr<osg::Vec3Array> myPoints;
         osg::ref_ptr<osg::Vec2Array> myTexCoords0;
         osg::ref_ptr<osg::Vec4Array> myBones;
         osg::ref_ptr<osg::Vec4Array> myWeights;

         unsigned int myVboPositionArray;
         unsigned int myVboTexCoords0Array;
         unsigned int myVboBonesArray;
         unsigned int myVboWeightsArray;
      };

      struct BoneWeight
      {
         BoneWeight()
            : myIndex(0)
            , myWeight(0)
         {
            // intentional nop
         }

         int myIndex;
         double myWeight;
      };

      virtual void freeData(void);

      virtual void computeWeights(float x, float y, float patchSize, float* bones, float* weights);

      virtual void initLod(int gridSize, float patchSize);

      virtual bool bindMeshGroupData(MeshGroup* meshGroup, osg::RenderInfo& renderInfo) const;

      virtual bool bindVaoToMeshGroup(GLuint vao, MeshGroup* meshGroup, osg::RenderInfo& renderInfo) const;

      virtual void computeBasis(const osg::Vec3d& inGeocentricPos, osg::Matrixd& rotOut);

      virtual void computeSortDepth(const osg::Vec3& camPos);

      virtual void inverseTransformPlane(osg::Vec4d& plane, const osg::Vec3d& position, const osg::Matrixd& rotation);

      virtual bool isSphereVisible(const std::vector<osg::Vec4d>& planes, const osg::Vec3d& center, double radius);

      virtual void computeBoundsCulling();

      virtual float computeEffectFade(const osg::Vec3& localCam);

      virtual double clampDistance() const;

      virtual bool clampPosition(osg::Vec3d& position);

      virtual float computePatchCellSize() const;

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

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

   protected:
      
      DtDe& myDe;

      float myDensity;
      bool myEnabled;

      float myWindU; // current pattern texture U offset for wind
      float myWindV; // current pattern texture V offset for wind
      double myLastWindTime; // last time wind was computed

      bool myCameraBasisDirty; // true if the basis needs computed from the camera
      bool myInitialized;
      bool myClampingEnabled;
      int myClampIndex;
      int myClampBoneIndex;
      float myMaxClampOffset; // the maximum computed abs(clamp offset)

      float myBaseColorR; // the red component of the base color
      float myBaseColorG; // the green component of the base color
      float myBaseColorB; // the blue component of the base color

      float myParticleSizeVariation; // particle size variation
                                     // base size + random(-myParticleSizeVariation, myParticleSizeVariation) * base size

      float myPatternedLook; // (-1 or 1) passed to shader to indicate patterned look or not
      AreaType myAreaType;

      MeshGroup* myMeshGroup;
      DtGlVaoManager* myVaoManager;

      osg::Vec3d myPosition;
      float myOrientation;
      osg::Vec3d myBasisPos;
      osg::Matrixd myBasisRot;

      float myBoundsX;
      float myBoundsY;
      float myBoundsCornerRadius;

      static const double DT_GFP_CLAMP_DISTANCE; // the skeletal terrain clamping distance (affects culling too)
      static const int DT_GFP_CELL_SIZE; // the number of cells in 1 row of a patch

      int myGridSize; // the number of patches in 1 row of a ground fog system
      float myPatchWorldSize;  // the world size of a patch: dimensions are (myPatchWorldSize x myPatchWorldSize x patchWorldHeight)
      std::vector<DtGroundFogPatch*> myPatches;
      int myPatchCount; // the total number of patches (myGridSize x myGridSize)
      DtGroundFogPatch** myRenderPatches; // pointer to dynamically allocated array of pointers used for draw queue
      int myRenderPatchCount;

      std::vector<DtGroundFogEffect*> myEffects;
   };


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

      virtual ~DtGroundFogPatchAreaCreator();

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

   public:
      virtual DtGroundFogPatchArea* create(float worldSize, float thickness) const;

      static DtGroundFogPatchAreaCreator& instance(DtDe& de);

      static const std::string& theClassName();

   protected:
      DtDe& myDe;
   };
}