DtOsgCullVisitorParameters.h

Go to the documentation of this file.

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

 
#pragma once
 

#include <vrvOsg/DtModelScaler.h>

#include <vrvIndirectRendering/DtIndirectModelScalingAlgorithm.h>
#include <vrvCore/DtObserverObject.h>

#include <osgUtil/CullVisitor>

#include <osg/BoundingBox>
#include <osg/BoundingSphere>
#include <osg/Vec2>


#include <matrix/vlMath.h>
#include <algorithm>
#include <math.h>

#ifdef min
#undef min
#endif

namespace makVrv 
{ 
   class DT_DLL_VRVOSG DtOsgCullVisitorParameters : public osg::Referenced
   {
   public:

      DtOsgCullVisitorParameters()
         : osg::Referenced()
         , mySkyFlag(true)
         , myDynamicLightsFlag(true)
         , myDynamicOceanFlag(true)
         , myCameraAboveWater(true)
         , myOrthoFlag(false)
         , myCameraResolution( 1.0 )
         , myTerrainRadius( 1.0 )
         , myScalingFlag( true )
         , myClampedPixelSize( 1.0 )
         , myLodScaleFactor( 1.0 )
         , myCoordinateSystemChanged( false )
         , myAltitude2D( 0. )
         , myDynamicWaterVisibilityEnable(true)
         , myDynamicWaterVisibilityMax(75.)
         , myModelScaler( 0 )
         , myTerrainMagnificationHighLodAngle(DtDeg2Rad(15))
         , myTerrainMagnificationScaleFactor(1.)
         , myCameraVelocity( 0, 0, 0 )
         , myModelSet(0)
         , myIncludeLightPoints(true)
         , myCurrentScaleFactor(1.0)
         , myIndirectDistScaleEnabled(false)
         , myIndirectDistScale(1.0)
         , myChannelLodScale(1.0f)
         , myFocusPointEnabled(false)
         , myFocusPoints()
      {
        
         //Intentional nop
      }

      inline void setLodScaleFactor( double sf )
      {
         myLodScaleFactor = sf;
      }

      inline double lodScaleFactor() const
      {
         return myLodScaleFactor;
      }

      void setCameraResolution(double factor)
      {
         myCameraResolution = factor;
      }

      inline double cameraResolution() const
      {
         return myCameraResolution;
      }
      void setCameraVelocity(double x, double y, double z)
      {
         myCameraVelocity = osg::Vec3d(x,y,z);
      }

      inline const osg::Vec3d& cameraVelocity() const
      {
         return myCameraVelocity;
      }

      void setTerrainRadius(double rad)
      {
         myTerrainRadius = rad;
      }

      void setAltitude2D( double altitude )
      {
         myAltitude2D = altitude;
      }

      double altitude2D() const
      {
         return myAltitude2D;
      }

      inline unsigned int modelSet() const
      {
         return myModelSet;     
      }

      void setModelSet(unsigned int modelSet)
      {
         myModelSet = modelSet;
      }

      inline double terrainRadius() const
      {
         return myTerrainRadius;
      }

      void setOrthoCulling(bool ortho)
      {
         myOrthoFlag = ortho;
      }

      inline bool orthoCulling() const
      {
         return myOrthoFlag;
      }

      inline void setSkyRendering(bool renderSky)
      {
         mySkyFlag = renderSky;

      }

      inline bool skyRendering() const
      {
         return mySkyFlag;
      }

      inline void setDynamicLights(bool enabled)
      {
         myDynamicLightsFlag = enabled;
      }

      inline bool dynamicLights() const
      {
         return myDynamicLightsFlag;
      }

      inline void setDynamicOcean(bool enabled)
      {
         myDynamicOceanFlag = enabled;
      }

      inline bool dynamicOcean() const
      {
         return myDynamicOceanFlag;
      }

      inline void setCameraAboveWater(bool aboveWater)
      {
         myCameraAboveWater = aboveWater;
      }

      inline bool cameraAboveWater() const
      {
         return myCameraAboveWater;
      }

      void setScaling( bool scaling )
      {
         myScalingFlag = scaling;
      }

      inline bool scaling() const
      {
         return myScalingFlag;
      }

      void setCoordinateSystemChanged( bool changed )
      {
         myCoordinateSystemChanged = changed;
      }

      inline bool coordinateSystemChanged() const
      {
         return myCoordinateSystemChanged;
      }

      inline void setModelScaler( DtModelScaler* scaler )
      {
         myModelScaler = scaler;
      }

      inline DtModelScaler* findModelScaler() const
      {
         return myModelScaler;
      }

      inline double calculateModelScale( const osg::Camera& camera, 
         const osg::Node& node ) const
      {
         if ( myModelScaler.valid() )
         {
            return myModelScaler->calculateScale( *this, camera, node );
         }
         else
         {
            return 1.;
         }
      }

      void setClampedPixelSize(double d)
      {
         myClampedPixelSize = d;
      }

      double clampedPixelSize() const
      {
         return myClampedPixelSize;
      }
      
      inline void setDynamicWaterVisibilityEnable( bool enable )
      {
         myDynamicWaterVisibilityEnable = enable;
      }

      inline bool dynamicWaterVisibilityEnable() const
      {  
         return myDynamicWaterVisibilityEnable;
      }

      inline void setDynamicWaterVisibilityMax( double visMax )
      {
         myDynamicWaterVisibilityMax = visMax;
      }

      inline double dynamicWaterVisibilityMax() const
      {
         return myDynamicWaterVisibilityMax;
      }

      inline void setTerrainMagnificationScaleFactor(float factor)
      {
         myTerrainMagnificationScaleFactor = factor;
      }

      inline float terrainMagnificationScaleFactor() const
      {
         return myTerrainMagnificationScaleFactor;
      }

      inline void setTerrainMagnificationHighLodAngle(float radians)
      {
         myTerrainMagnificationHighLodAngle = radians;
      }

      inline float terrainMagnificationHighLodAngle() const
      {
         return myTerrainMagnificationHighLodAngle;
      }

      inline void setIncludeLightPoints(bool flag)
      {
         myIncludeLightPoints = flag;
      }

      inline bool includeLightPoints() const
      {
         return myIncludeLightPoints;
      }

      inline float currentTraversalScaleFactor()
      {
         return myCurrentScaleFactor;
      }

      inline void setCurrentTraversalScaleFactor(float currentScaleFactor)
      {
         myCurrentScaleFactor = currentScaleFactor;
      }

      inline void setIndirectDistanceScaleEnabled(bool enabled)
      {
         myIndirectDistScaleEnabled = enabled;
      }

      inline bool indirectDistanceScaleEnabled() const
      {
         return myIndirectDistScaleEnabled;
      }

      inline void setIndirectDistanceScale(float scale)
      {
         myIndirectDistScale = scale;
      }

      inline float indirectDistanceScale() const
      {
         return myIndirectDistScale;
      }

      inline void setChannelLodScale(float scale)
      {
         myChannelLodScale = scale;
      }
   
      inline float channelLodScale()
      {
         return myChannelLodScale;
      }

      inline void setFocusPoints(std::vector<osg::Vec3d>& points)
      {
         myFocusPoints = points;
      }

      inline std::vector<osg::Vec3d>& focusPoints()
      {
         return myFocusPoints;
      }

      inline void setFocusPointEnabled(bool enable)
      {
         myFocusPointEnabled = enable;
      }

      inline bool focusPointEnabled()
      {
         return myFocusPointEnabled;
      }

      virtual DtIndirectModelScalingAlgorithm indirectModelScalingAlgorithm(void) const;

   protected:

      double myLodScaleFactor;
      double myCameraResolution;
      double myTerrainRadius;
      double myAltitude2D;
      bool mySkyFlag;
      bool myDynamicLightsFlag;
      bool myDynamicOceanFlag;
      bool myCameraAboveWater;
      bool myOrthoFlag;
      bool myScalingFlag;
      double myClampedPixelSize;
      bool myCoordinateSystemChanged;
      bool myDynamicWaterVisibilityEnable;
      double myDynamicWaterVisibilityMax;
      osg::ref_ptr<DtModelScaler> myModelScaler;
      float myTerrainMagnificationScaleFactor;
      float myTerrainMagnificationHighLodAngle;
      osg::Vec3d myCameraVelocity;
      unsigned int myModelSet;
      bool myIncludeLightPoints;
      float myCurrentScaleFactor;
      bool myIndirectDistScaleEnabled;
      float myIndirectDistScale;
      std::vector<osg::Vec3d> myFocusPoints;
      
      float myChannelLodScale;
      bool myFocusPointEnabled;
   };

   class DT_DLL_VRVOSG DtOsgFixedScaleParameters : public osg::Referenced
   {
   public:
      DtOsgFixedScaleParameters()
         : myFixedPixelSize( 1.0 )
         , myLength( 0.0 )
         , myWidth( 0.0 )
         , myHeight( 0.0 )
         , myScaleX(true)
         , myScaleY(true)
         , myScaleZ(true)
      {
} 

      virtual ~DtOsgFixedScaleParameters()
      {
      }
 
      void setFixedPixelSize(double d)
      {
         myFixedPixelSize = d;
      }

      double fixedPixelSize() const
      {
         return myFixedPixelSize;
      }

      void setDimensions(double length, double width, double height)
      {
         myLength = length; myWidth = width; myHeight = height;
      }

      inline double length() const
      {
         return myLength;
      }

      inline double width() const
      {
         return myWidth;
      }

      inline double height() const
      {
         return myHeight;
      }

      inline void calculateScaleFactors(const osgUtil::CullVisitor& visitor,
         const osg::BoundingSphere& sphere, DtOsgCullVisitorParameters* info,
         double& scaleFactorX, double& scaleFactorY, double& scaleFactorZ) const
      {
         double clampedSize =
            visitor.clampedPixelSize( sphere.center(), info->terrainRadius() );
         info->setClampedPixelSize(clampedSize);

         calculateScaleFactors( sphere, *info, scaleFactorX,
            scaleFactorY, scaleFactorZ );
      }

      inline void calculateScaleFactors(const osg::BoundingSphere& sphere, const DtOsgCullVisitorParameters& info,
         double& scaleFactorX, double& scaleFactorY, double& scaleFactorZ) const
      {
         scaleFactorX = scaleFactorY = scaleFactorZ = 1.0;

         double metersPerPixel = info.terrainRadius() / info.clampedPixelSize();  // Meters per pixel
         double curPixels = myWidth / metersPerPixel;  // Pixels needed to draw

         if (myScaleX)
         {
            scaleFactorX = myFixedPixelSize / curPixels;
         }

         if (myScaleY)
         {
            scaleFactorY = scaleFactorX;
         }

         if (myScaleX)
         {
            scaleFactorZ = 1.0;
         }
      }

      void setScaleX(bool b)
      {
         myScaleX = b;
      }

      inline bool scaleX() const
      {
         return myScaleX;
      }

      void setScaleXY(bool b)
      {
         myScaleY = b;
      }

      inline bool scaleY() const
      {
         return myScaleY;
      }

      void setScaleZ(bool b)
      {
         myScaleZ = b;
      }

      inline bool scaleZ() const
      {
         return myScaleZ;
      }

   protected:
      double myFixedPixelSize;
      double myLength, myWidth, myHeight;
      bool myScaleX, myScaleY, myScaleZ;
   };

}