include/vrvOsg/DtOsgCullVisitorParameters.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (c) 2011 MAK Technologies, Inc.
 * All rights reserved.
 *****************************************************************************/
/*****************************************************************************
 * $RCSfile: DtOsgCullVisitorParameters.h,v $ $Revision: 1.51 $ $State: Exp $
 *****************************************************************************/
 
 
#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 <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)
         , 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. )
      {
      }

      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 setTerrainRadius(double rad)
      {
         myTerrainRadius = rad;
      }

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

      double altitude2D() const
      {
         return myAltitude2D;
      }

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

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

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

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

      inline double calculateFixedScale(double basempp, double mpp )
      {
         return mpp / basempp;
      }

      inline double calculateScaleFromDistance(double distance, double r )
      {
         double distsqr = distance * distance;
         double scaleDistRatio = 250 - 2.0 * myScaleFactor;
         double scaleBasedOnDistance = sqrt(distsqr)/scaleDistRatio;
         
         // Calculate a scale for the entity based on its size.
         // Scale the scale so that big entities are scaled less and 
         // small entities are scaled more.  For example, a lifeform model
         // should be only slightly smaller than a helicopter and a large
         // submarine should only be a few times bigger than a helicopter
         if ( r > 0.0 )
         {
            //double scaleScale = 3.0 / sqrt(r);   
            double scaleScale = 6.0 / r;   
            scaleBasedOnDistance *= scaleScale;
         }
            
         if (scaleBasedOnDistance < 1.0) 
         {
            scaleBasedOnDistance = 1.0;
         }   

         return scaleBasedOnDistance;
      }

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

      double clampedPixelSize() const
      {
         return myClampedPixelSize;
      }

   protected:

      double myCameraMagnification;
      double myCameraResolution;
      double myTerrainRadius;
      double myAltitude2D;
      bool mySkyFlag;
      bool myOrthoFlag;
      bool myScalingFlag;
      double myScaleFactor;
      double myClampedPixelSize;
      DtObserverObject::ScaleType myScaleType;
      bool myCoordinateSystemChanged;
   };

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

}