DtWeatherArea.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtDe.h>
#include <vrvCore/DtSkyObject.h>

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

#include <vrvUtil/DtVirtualBaseClass.h>

#include <matrix/vlVector.h>

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

#include <boost/unordered_map.hpp>
#include <vector>


namespace makVrv
{
   // Forward declarations.
   class DtJobSplitter;
   class DtWeatherAreaCreator;
   class DtIntersector;

   class DT_DLL_VRVOSG DtWeatherArea : public DtVirtualBaseClass
   {
      friend class DtWeatherAreaFactory;

   public:

      virtual ~DtWeatherArea();

      DtWeatherArea() = delete;

      DtWeatherArea(const DtWeatherArea &other) = delete;

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

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

   public:
      virtual void setEnabled(bool enabled);

      virtual bool enabled() const;

      virtual bool culled() const;

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

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

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

      virtual const osg::Matrixd& rotation() const;

      virtual float boundsX() const;

      virtual float boundsY() const;

      virtual float boundsZ() const;

      virtual float boundsCornerRadius() const;

      virtual const unsigned int* packedData(int& sizeX, int& sizeY) const;

      virtual void cullUpdate(const osg::Vec3d& camPos,
         const std::vector<osg::Vec4d>& cullingPlanes, DtJobSplitter* jobSplitter,
         const osg::Camera* camera);

      virtual void drawWeatherLayerEffects(DtWeatherEffect::DrawData& drawData);

      static float computeBoundsDistance2d(const osg::Vec3d& position,
         const osg::Vec4d& bounds, const osg::Vec3d& boundsPosition,
         const osg::Matrixd& boundsRotation);

      static float computeBoundsDistance3d(const osg::Vec3d& position,
         const osg::Vec4d& bounds, const osg::Vec3d& boundsPosition,
         const osg::Matrixd& boundsRotation);

      static float computeBoundsDistance2dAndTop(const osg::Vec3d& position,
         const osg::Vec4d& bounds, const osg::Vec3d& boundsPosition,
         const osg::Matrixd& boundsRotation);

      virtual float computeBoundsDistance2d(const osg::Vec3d& position);

      virtual float computeBoundsDistance3d(const osg::Vec3d& position);

      virtual float computeBoundsDistance2dAndTop(const osg::Vec3d& position);

      virtual void setPrecipitationIntensity(const float intensity);

      virtual const float precipitationIntensity() const;

      virtual void setPrecipitationType(const DtSkyObject::PrecipitationType type);

      virtual const DtSkyObject::PrecipitationType precipitationType() const;

      virtual void setGroundRainAccumulation(const float depth);

      virtual const float groundRainAccumulation() const;

      virtual void setFogColor(const DtVector& color);

      virtual const DtVector& fogColor() const;

      virtual void setVisibilityDistance(const float distance);

      virtual const float visibilityDistance() const;

      virtual void setOvercast(const float overcast);

      virtual const float overcast() const;

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

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

      virtual void setLightningEnabled(const bool enabled);

      virtual const bool lightningEnabled() const;

      virtual void cloudLayerAdded(DtCloudLayerId layerId, int cloudType);

      virtual void cloudLayerRemoved(DtCloudLayerId layerId);

      virtual bool computeLocalPrecipitation(const osg::Vec3d& location,
         int& type, float& intensity);

      virtual bool computeLocalGroundRainAccumulation(const osg::Vec3d& location,
         float& depth, float& blend);

      virtual void addWeatherLayer(DtWeatherLayer::LayerType layerType);

      virtual void removeWeatherLayer(DtWeatherLayer::LayerType layerType);

   protected:

      virtual void updateTransform();

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

      virtual bool clampPositionToTerrain(osg::Vec3d& position, float clampDistance) const;

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

      virtual bool isPositionBelowSealevel(const DtVector& position) const;

   protected:
  
      DtDe& myDe;

      bool myEnabled;
      bool myCulled;

      DtVector mySetPosition;
      float mySetOrientation;
      bool mySetRelativeToCamera;

      osg::Vec3d myPosition;   // computed world position
      osg::Matrixd myRotation; // computed world rotation

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

      float myPrecipitationBoundsScale;
      float myPrecipitationIntensity;
      DtSkyObject::PrecipitationType myPrecipitationType;

      float myGroundRainAccumulation;

      bool myLightningEnabled;

      DtVector myFogColor;
      float myVisibilityDistance;
      float myOvercast;

      float myWindDirectionRad;
      float myWindSpeedMps;

      std::vector<DtWeatherLayer*> myWeatherLayers;

      DtIntersector* myIntersector = nullptr;
   };



   class DT_DLL_VRVOSG DtWeatherAreaFactory : public DtVirtualBaseClass
   {
   public:

      enum AreaType
      {
         AreaTypeDefault,
         AreaTypeBlowingDust,
         AreaTypeBlowingSand,
         AreaTypeBlowingSnow,
         AreaTypeEnvironmental
      };

      DtWeatherAreaFactory(DtDe &de);

      virtual ~DtWeatherAreaFactory();

      DtWeatherAreaFactory() = delete;

      DtWeatherAreaFactory(const DtWeatherAreaFactory &other) = delete;

      DtWeatherAreaFactory &operator=(const DtWeatherAreaFactory &other) = delete;
      
      static DtWeatherAreaFactory& instance(DtDe& de);

      static const std::string& theClassName();

      virtual DtWeatherArea* create(AreaType areaType) const;

   protected:

      DtDe& myDe;
   };

}