DtOsgCullVisitorParameters.h

Go to the documentation of this file.

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

 
#pragma once
 
#include <vrvOsg/vrvOsg.h> 
#include <osg/Referenced>
#include <osg/BoundingBox>
#include <osg/BoundingSphere>
#include <osg/Vec2>
#include <osgUtil/CullVisitor>

#include <vrvCore/DtObserverObject.h>

#include <vrvUtil/DtVirtualBaseClass.h>

#include <vrvOsg/DtOsgNodeXRScaler.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)
         , myOrthoFlag(false)
         , myCameraResolution( 1.0 )
         , myTerrainRadius( 1.0 )
         , myScalingFlag( true )
         , myScaleFactor( 1.0 )
         , myClampedPixelSize( 1.0 )
         , myCameraMagnification( 1.0 )
         , myScaleType( DtObserverObject::XRScale )
         , myCoordinateSystemChanged( false )
         , myAltitude2D( 0. )
         , myAltitude3D( 0. )
         , myDynamicWaterVisibilityEnable(true)
         , myDynamicWaterVisibilityMax(75.)
         , myNodeXRScaler( 0 )
         , myPagedLodMagnificationScaleFactor(1.)
         , myCameraVelocity( 0 )
         , myModelSet(0)
      {
      }

      inline void setCameraMagnification( double mag )
      {
         myCameraMagnification = mag;
      }

      inline double cameraMagnification() const
      {
         return myCameraMagnification;
      }

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

      inline double cameraResolution() const
      {
         return myCameraResolution;
      }
      void setCameraVelocity(double velocity)
      {
         myCameraVelocity = velocity;
      }

      inline double 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;
      }

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

      inline bool scaling() const
      {
         return myScalingFlag;
      }
      
      void setScaleFactor( double scaleFactor )
      {
         myScaleFactor = scaleFactor;
      }

      inline double scaleFactor() const
      {  
         return myScaleFactor;
      }
      
      void setCoordinateSystemChanged( bool changed )
      {
         myCoordinateSystemChanged = changed;
      }

      inline bool coordinateSystemChanged() const
      {
         return myCoordinateSystemChanged;
      }

      inline void setNodeXRScaler( DtOsgNodeXRScaler* scaler )
      {
         myNodeXRScaler = scaler;
      }

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

      void setScaleType( DtObserverObject::ScaleType scaleType )
      {
         myScaleType = scaleType;
      }

      inline DtObserverObject::ScaleType scaleType() const
      {  
         return myScaleType;
      }

      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 setPagedLodMagnificationScaleFactor(float factor)
      {
         myPagedLodMagnificationScaleFactor = factor;
      }

      inline float pagedLodMagnificationScaleFactor() const
      {
         return myPagedLodMagnificationScaleFactor;
      }

   protected:

      double myCameraMagnification;
      double myCameraResolution;
      double myTerrainRadius;
      double myAltitude2D;
      double myAltitude3D;
      bool mySkyFlag;
      bool myDynamicLightsFlag;
      bool myDynamicOceanFlag;
      bool myOrthoFlag;
      bool myScalingFlag;
      double myScaleFactor;
      double myClampedPixelSize;
      DtObserverObject::ScaleType myScaleType;
      bool myCoordinateSystemChanged;
      bool myDynamicWaterVisibilityEnable;
      double myDynamicWaterVisibilityMax;
      osg::ref_ptr<DtOsgNodeXRScaler> myNodeXRScaler;
      float myPagedLodMagnificationScaleFactor;
      double myCameraVelocity;
      unsigned int myModelSet;
   };

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

}