DtGroundFogGroup.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <osg/Group>

#include <vrvOsg/DtOsgCullVisitorParameters.h>
#include <vrvOsg/DtGroundFogEffect.h>
#include <vrvOsg/DtGroundFogPatchArea.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtVirtualBaseClass.h>

#include <vrvCore/DtCloudLayer.h>


namespace makVrv
{
   // Forward declarations.
   class DtGroundFogEffectDrawable;
   class DtGroundFogPatchDrawable;
   class DtJobSplitter;


   class DT_DLL_VRVOSG DtGroundFogGroup : public osg::Group
   {
   public:

      enum SENSOR_MATERIAL
      {
         SENSOR_MATERIAL_NONE = 0,
         SENSOR_MATERIAL_PATCHY_GROUND_FOG,
         SENSOR_MATERIAL_SANDSTORM,
         SENSOR_MATERIAL_SANDSTORM_EFFECT,
         SENSOR_MATERIAL_COUNT
      };

      DtGroundFogGroup(DtDe& de);

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

      virtual ~DtGroundFogGroup();

   private:

      DtGroundFogGroup(const DtGroundFogGroup &other);

      DtGroundFogGroup &operator=(const DtGroundFogGroup &other);

   public:

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

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

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

      virtual void deleteGeode();

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

      virtual void removeCloudLayer(DtCloudLayerId layerId);

      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 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 setCloudLayerDensity(DtCloudLayerId layerId, float density);

      virtual void setCloudLayerEnabled(DtCloudLayerId layerId, bool enabled);

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

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

      virtual void setCloudLayerParticleSizeVariation(DtCloudLayerId layerId, float variation);

      virtual void setCloudLayerPatternedLook(DtCloudLayerId layerId, bool patternedEnable);

      virtual void setWind(float windDirectionRad, float windSpeedMps);

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

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

   protected:

      struct HeightFogItem
      {
         HeightFogItem()
            : myLayerId(0)
            , 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
         }

         int myLayerId;
         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;
      };

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

      void setHeightFogTransform(HeightFogItem* item, const DtVector& position, bool relativeToCamera);

   protected:

      DtDe& myDe;

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

      osg::ref_ptr<osg::Group> myGroundFogSensorGroup;
      osg::ref_ptr<osg::Geode> myGroundFogGeode;
      osg::ref_ptr<makVrv::DtGroundFogPatchDrawable> myGroundFogPatchDrawable;

      osg::ref_ptr<osg::Group> myEffectSensorGroup;
      osg::ref_ptr<osg::Geode> myEffectGeode;
      osg::ref_ptr<makVrv::DtGroundFogEffectDrawable> myEffectDrawable;

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

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

      DtJobSplitter* myJobSplitter;

   private:

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

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

   class DT_DLL_VRVOSG DtGroundFogGroupCreator : public DtVirtualBaseClass
   {

   public:

      static DtGroundFogGroupCreator& instance(DtDe& theIG);

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

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