DtWeatherAreaGroup.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <osg/Camera>
#include <osg/Group>

#include <vrvOsg/DtOsgCullVisitor.h>
#include <vrvOsg/DtOsgCullVisitorParameters.h>
#include <vrvOsg/DtGroundFogEffect.h>
#include <vrvOsg/DtGroundFogPatchArea.h>
#include <vrvOsg/DtWeatherAreaDrawable.h>
#include <vrvOsg/DtWeatherLayer.h>
#include <vrvOsg/DtWeatherLightning.h>
#include <vrvOsg/DtWeatherRainShaft.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <vrvCore/DtCloudLayer.h>
#include <vrvCore/DtWeatherAreaObjectManager.h>

#include <matrix/vlVector.h>


namespace makVrv
{
   // Forward declarations.
   class DtJobSplitter;
   class DtWeatherArea;
   class DtWeatherFogFroxelGrid;


   class DT_DLL_VRVOSG DtWeatherAreaGroup : public osg::Group
   {
   public:

      enum SensorMaterialType
      {
         SensorMaterialTypeNone = 0,
         SensorMaterialTypePatchyGroundFog,
         SensorMaterialTypeSandstorm,
         SensorMaterialTypeSandstormEffect,
         SensorMaterialTypeRainShaft,
         SensorMaterialTypeLightning,
         SensorMaterialTypeCount
      };

      enum DrawItemType
      {
         DrawItemTypeNone = 0,
         DrawItemTypeGroundFogPatchArea,
         DrawItemTypeGroundFogEffect,
         DrawItemTypeRainShaft,
         DrawItemTypeLightning,
      };

      DtWeatherAreaGroup(DtDe& de);

      DtWeatherAreaGroup(const DtWeatherAreaGroup& orig, const osg::CopyOp& opr);

      virtual ~DtWeatherAreaGroup();

      DtWeatherAreaGroup() = delete;

      DtWeatherAreaGroup(const DtWeatherAreaGroup &other) = delete;

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

   public:

      virtual void init();

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

      virtual osg::Object* clone(const osg::CopyOp& copyop) const { return new DtWeatherAreaGroup(*this, copyop); }
      virtual osg::Object* cloneType() const { return NULL; }

      virtual void deleteGeode();

      // !\brief Gets the sensor node associated with the given material type
      // !\param matType The material type enumeration.
      virtual osg::Node* getOrCreateSensorNode(SensorMaterialType matType);

      virtual bool usingWeatherLayerType(DtWeatherLayer::LayerType layerType) const;

      virtual void removeCloudLayer(DtCloudLayerId layerId);

      virtual bool removeHeightFog(DtUniqueID uniqueId);

      virtual void removeCloudLayers();

      virtual void addGroundFog(DtCloudLayerId layerId, const DtVector& position,
         float orientation, float cornerRadius, const DtVector& bounds,
         double density, bool infinite, bool relative, bool altitudeIsHAT);

      virtual DtUniqueID addHeightFog(const DtVector& position, float orientation,
         float cornerRadius, const DtVector& bounds, double density, bool relative);

      virtual void addPatchyGroundFog(DtCloudLayerId layerId,
         const DtVector& position, float orientation, float cornerRadius,
         const DtVector& bounds, double density, bool relative);
    
      virtual void addSandstorm(DtCloudLayerId layerId, const DtVector& position,
         float orientation, float cornerRadius, const DtVector& bounds,
         double density, bool infinite, bool relative, bool altitudeIsHAT);

      virtual void addBlowingDustArea(DtCloudLayerId layerId,
         const DtVector& position, float orientation, float cornerRadius,
         const DtVector& bounds, bool relative);

      virtual void addBlowingSandArea(DtCloudLayerId layerId,
         const DtVector& position, float orientation, float cornerRadius,
         const DtVector& bounds, bool relative);

      virtual void addBlowingSnowArea(DtCloudLayerId layerId,
         const DtVector& position, float orientation, float cornerRadius,
         const DtVector& bounds, bool relative);

      virtual DtUniqueID addRainShaft(osg::Vec3d& position, const osg::Matrixd& rotation,
         const DtVector& bounds, const float cornerRadius, const float intensity);

      virtual void removeRainShaft(DtUniqueID uniqueId);

      virtual void setWeatherRainShaftBounds(DtUniqueID uniqueId,
         const DtVector& bounds, const float cornerRadius);

      virtual void setWeatherRainShaftTransform(DtUniqueID uniqueId,
         const osg::Vec3d& position, const osg::Matrixd& rotation);

      virtual void setWeatherRainShaftIntensity(DtUniqueID uniqueId,
         const float intensity);

      virtual void setWeatherRainShaftBaseColor(DtUniqueID uniqueId,
         const DtVector& color);

      virtual void setWeatherRainShaftWind(DtUniqueID uniqueId,
         const float windDirectionRad, const float windSpeedMps);

      virtual void setWeatherRainShaftEnabled(DtUniqueID uniqueId, bool enabled);

      virtual DtUniqueID addLightning(osg::Vec3d& position,
         const osg::Matrixd& rotation, const DtVector& bounds,
         const float cornerRadius, const float intensity);

      virtual void removeLightning(DtUniqueID uniqueId);

      virtual void setWeatherLightningBounds(DtUniqueID uniqueId,
         const DtVector& bounds, const float cornerRadius);

      virtual void setWeatherLightningTransform(DtUniqueID uniqueId,
         const osg::Vec3d& position, const osg::Matrixd& rotation);

      virtual void setWeatherLightningIntensity(DtUniqueID uniqueId,
         const float intensity);

      virtual void setWeatherLightningEnabled(DtUniqueID uniqueId, bool enabled);

      virtual void setCloudLayerDensity(DtCloudLayerId layerId, float density);

      virtual void setHeightFogDensity(DtUniqueID uniqueId, float density);

      virtual void setCloudLayerEnabled(DtCloudLayerId layerId, bool enabled);

      virtual void setHeightFogEnabled(DtUniqueID uniqueId, bool enabled);

      virtual void setCloudLayerPositionAndOrientation(DtCloudLayerId layerId,
         const DtVector& position, float orientation);

      virtual void setHeightFogPositionAndOrientation(DtUniqueID uniqueId,
         const DtVector& position, float orientation, bool relative);

      virtual void setCloudLayerBaseColor(DtCloudLayerId layerId,
         float red, float green, float blue);

      virtual void setHeightFogBaseColor(DtUniqueID uniqueId,
         float red, float green, float blue);

      virtual void setHeightFogBounds(DtUniqueID uniqueId,
         const DtVector& bounds, const float cornerRadius);

      virtual void setCloudLayerParticleSizeVariation(DtCloudLayerId layerId,
         float variation);

      virtual void setCloudLayerPatternedLook(DtCloudLayerId layerId,
         bool patternedEnable);

      virtual void setWind(float windDirectionRad, float windSpeedMps);

      virtual void drawObjects(osg::RenderInfo& renderInfo,
         const DtWeatherAreaDrawable& drawable);

      virtual void gatherWeatherAreas(const osg::Vec3d& position,
         std::vector<DtWeatherArea*>& areas);

      virtual bool computeLocalPrecipitation(const DtVector& location,
         int& precipType, float& intensity);

      virtual bool computeLocalGroundRainAccumulation(const DtVector& location,
         float& depth, float& blend);

      virtual bool shouldActivateRaindrops() const;

      virtual bool bindFogFroxelTexture(const int unit, const unsigned int renderContextId);

      virtual float fogFroxelMaxDistance() const;

   protected:

      struct DrawItem
      {
         DrawItem()
            : mySortDistance(0)
            , mySortPriority(0)
            , myItemType(DrawItemTypeNone)
            , myItem(0)
         {
            // intentional noop
         }

         int mySortDistance; // squared distance from camera
         int mySortPriority; // lower number draws first
         DrawItemType myItemType;
         void* myItem;
      };

      struct DrawItemSortDistanceComparator
      {
      public:
         bool operator()(const DtWeatherAreaGroup::DrawItem& lhs,
            const DtWeatherAreaGroup::DrawItem& rhs);
      };

      struct HeightFogItem
      {
         HeightFogItem()
            : myUniqueId(-1)
            , myEnabled(true)
            , myBasisPos(0,0,0)
            , myCameraBasisDirty(false)
            , myPosition(0,0,0)
            , myAltitude(0)
            , myDensity(0.001f)
            , myAltitudeBlend(0)
            , myDensityBlend(0)
            , myCornerRadius(1)
            , myBounds(1,1,1)
            , myBaseColor(1,1,1)
         {
            //intentional nop
         }

         DtUniqueID myUniqueId;
         bool myEnabled;
         osg::Vec3d myPosition;
         osg::Vec3d myBasisPos;
         osg::Matrixd myBasisRot;
         bool myCameraBasisDirty; // true when transform was set relative to camera
         float myAltitude;
         float myDensity;
         float myAltitudeBlend;
         float myDensityBlend;
         float myCornerRadius;
         DtVector myBounds; // x = length, y = width, z = thickness
         osg::Vec3 myBaseColor;
      };

      struct SoftnessUniforms
      {
         osg::ref_ptr<osg::Uniform> myInvPersMatrixUniform;
         osg::ref_ptr<osg::Uniform> myPersMatrixUniform;
         osg::ref_ptr<osg::Uniform> myViewportUniform;
         osg::ref_ptr<osg::Uniform> myIsReflectionUniform;
         osg::ref_ptr<osg::Uniform> mySoftnessUniform;
      };

      struct GroundFogPatchState
      {
         GroundFogPatchState() : myPatternTextureWidth(1.0f)
         {
            // intentional noop
         }

         SoftnessUniforms mySoftnessUniforms;
         osg::ref_ptr<osg::Uniform> myViewMatrixInvUniform;
         float myPatternTextureWidth;
      };

      struct GroundFogEffectState
      {
         SoftnessUniforms mySoftnessUniforms;
         osg::ref_ptr<osg::Uniform> myViewMatrixInvUniform;
      };

      struct RainShaftState
      {
         SoftnessUniforms mySoftnessUniforms;
         osg::ref_ptr<osg::Uniform> myViewMatrixInvUniform;
      };

      struct LightningState
      {
         SoftnessUniforms mySoftnessUniforms;
      };

      virtual void initGroundFogPatchState();

      virtual void initSandstormState();

      virtual void initGroundFogEffectState();

      virtual void initRainShaftState();

      virtual void initLightningState();

      virtual void loadShaders();

      virtual void loadGroundFogPatchShaders();

      virtual void loadSandstormShaders();

      virtual void loadGroundFogEffectShaders();

      virtual void loadRainShaftShaders();

      virtual void loadLightningShaders();

      virtual void clearDrawBins();

      void flushDrawBin(osg::RenderInfo& renderInfo,
         const DtWeatherAreaDrawable& drawable, std::vector<DrawItem>& drawBin);

      virtual void drawGroundFogPatchArea(DtGroundFogPatchArea::DrawData& drawData,
         DtGroundFogPatchArea* area, const bool stateDirty);

      virtual void drawGroundFogEffect(DtGroundFogEffect::DrawData& drawData,
         DtGroundFogPatchArea* area, const bool stateDirty);

      virtual void drawRainShaft(DtWeatherRainShaft::DrawData& drawData,
         DtWeatherRainShaft* shaft, const bool stateDirty);

      virtual void drawLightning(DtWeatherLightning::DrawData& drawData,
         DtWeatherLightning* lightning, const bool stateDirty);

      virtual void applyState(DtGroundFogPatchArea::DrawData& drawData,
         GroundFogPatchState& mutableState) const;

      virtual void applyState(DtGroundFogEffect::DrawData& drawData) const;

      virtual void applyState(DtWeatherRainShaft::DrawData& drawData) const;

      virtual void applyState(DtWeatherLightning::DrawData& drawData) const;

      virtual void initSoftnessUniforms(osg::StateSet& ss,
         SoftnessUniforms& softnessUniforms);

      virtual void setupSoftness(osg::Camera* camera,
         SoftnessUniforms& softnessUniforms) const;

      void connectSignals();

      virtual void slot_reloadShaders();

      virtual void slot_simulationUpdate();

      virtual void slot_weatherAreaObjectAdded(DtUniqueID id, DtWeatherAreaObject*);

      virtual void slot_weatherAreaObjectToBeRemoved(DtUniqueID id, DtWeatherAreaObject*);

      virtual void slot_weatherAreaObjectTransformChanged(DtUniqueID id,
         const DtVector& position, const float orientation);

      virtual void slot_weatherAreaObjectBoundsChanged(DtUniqueID id,
         const DtVector& bounds, const float cornerRadius);

      virtual void slot_weatherAreaObjectPrecipitationIntensityChanged(
         DtUniqueID id, const float intensity);

      virtual void slot_weatherAreaObjectPrecipitationTypeChanged(
         DtUniqueID id, const unsigned int type);

      virtual void slot_weatherAreaObjectGroundRainAccumulationChanged(
         DtUniqueID id, const float depth);

      virtual void slot_weatherAreaObjectFogColorChanged(DtUniqueID id,
         const DtVector& color);

      virtual void slot_weatherAreaObjectVisibilityDistanceChanged(
         DtUniqueID id, const float distance);

      virtual void slot_weatherAreaObjectOvercastChanged(DtUniqueID id,
         const float distance);

      virtual void slot_weatherAreaObjectLightningEnabledChanged(
         DtUniqueID id, const bool enabled);

      virtual void traverse(osg::NodeVisitor& nv);

      virtual void disableHeightFog();

      virtual void cullUpdate(osg::Camera* cam);

      virtual void cullUpdateHeightFog(osg::Camera* cam);

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

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

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

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

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

   protected:

      DtDe& myDe;

      float myWindSpeedMps;
      float myWindDirectionRad;

      osg::ref_ptr<osg::Node> mySensorNodes[SensorMaterialTypeCount];

      osg::ref_ptr<osg::Group> mySortPreCloudsGroupNode;
      osg::ref_ptr<osg::Geode> mySortPreCloudsGeode;
      osg::ref_ptr<makVrv::DtWeatherAreaDrawable> mySortPreCloudsDrawable;

      osg::ref_ptr<osg::Group> mySortPostCloudsGroupNode;
      osg::ref_ptr<osg::Geode> mySortPostCloudsGeode;
      osg::ref_ptr<makVrv::DtWeatherAreaDrawable> mySortPostCloudsDrawable;

      osg::ref_ptr<osg::Group> mySortTransparentGroupNode;
      osg::ref_ptr<osg::Geode> mySortTransparentGeode;
      osg::ref_ptr<makVrv::DtWeatherAreaDrawable> mySortTransparentDrawable;

      osg::ref_ptr<osg::Group> myGroundFogPatchSensorGroup;
      osg::ref_ptr<osg::Group> mySandstormSensorGroup;
      osg::ref_ptr<osg::Group> myGroundFogEffectSensorGroup;
      osg::ref_ptr<osg::Group> myWeatherRainShaftSensorGroup;
      osg::ref_ptr<osg::Group> myWeatherLightningSensorGroup;

      std::vector<DrawItem> myPreSortBin;
      std::vector<DrawItem> mySortBinPreClouds;
      std::vector<DrawItem> mySortBinPostClouds;
      std::vector<DrawItem> mySortBinTransparent;

      // Needs to be mutable because it's used during draw implementation.
      mutable GroundFogPatchState myMutableGroundFogPatchState;
      mutable GroundFogPatchState myMutableSandstormState;
      mutable GroundFogEffectState myMutableGroundFogEffectState;
      mutable RainShaftState myMutableRainShaftState;
      mutable LightningState myMutableLightningState;

      typedef std::map< DtUniqueID, HeightFogItem > DtHeightFogMap;
      DtHeightFogMap myHeightFogMap;

      typedef std::map< DtCloudLayerId, DtUniqueID > DtCloudLayerIdToUniqueIdMap;
      DtCloudLayerIdToUniqueIdMap myCloudLayerIdToUniqueIdMap;

      std::vector<osg::Vec4d> myCullingPlanes;

      double myLastTime;
      float myTimeStep;

      DtJobSplitter* myJobSplitter;

      DtSignalConnectionManager myConnections;

      DtWeatherFogFroxelGrid* myWeatherFogFroxelGrid;

   private:

      osg::Node* getChildNodeByName(osg::Group* parent, const char* name);

      typedef std::map< DtCloudLayerId, DtGroundFogPatchArea* > DtGroundFogPatchAreaMap;
      mutable DtGroundFogPatchAreaMap myMutableGroundFogPatchAreaMap;

      typedef std::map< DtCloudLayerId, DtWeatherArea* > DtWeatherAreaMap;
      mutable DtWeatherAreaMap myMutableWeatherAreaMap;

      typedef std::map< DtUniqueID, DtWeatherArea* > DtWeatherAreaObjectMap;
      mutable DtWeatherAreaObjectMap myMutableWeatherAreaObjectMap;

      typedef std::map< DtUniqueID, DtWeatherRainShaft* > DtWeatherRainShaftMap;
      mutable DtWeatherRainShaftMap myMutableWeatherRainShaftMap;

      typedef std::map< DtUniqueID, DtWeatherLightning* > DtWeatherLightningMap;
      mutable DtWeatherLightningMap myMutableWeatherLightningMap;
   };



   class DT_DLL_VRVOSG DtWeatherAreaGroupCreator : public DtVirtualBaseClass
   {

   public:
      DtWeatherAreaGroupCreator();

      virtual ~DtWeatherAreaGroupCreator();

      DtWeatherAreaGroupCreator(const DtWeatherAreaGroupCreator &other) = delete;

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

      static DtWeatherAreaGroupCreator& instance(DtDe& theIG);

      static void registerInstance(DtDe& theIG, DtWeatherAreaGroupCreator* anInstance);

      virtual DtWeatherAreaGroup* create(DtDe&);
   };
}