DtOsgObserverObject.h

Go to the documentation of this file.

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


#pragma once

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

#include <vrvCore/DtObserverObject.h>

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

#include <osg/Matrixd>
#include <osg/Vec3d>
#include <osg/Vec3>
#include <osg/Node>

#include <list>
#include <unordered_map>

class DtTaitBryan;

namespace osg
{
   class Node;
}

namespace makVrv 
{
   class DtChannel;
   class DtOsgChannel;
   class DtCoordinateConverter;
   class DtSceneObject;
   class DtTerrainPatchObject;
   class DtAgentUpdateResolverInterface;
   class DtIntersectorsContainer;
   class DtCoordinateSystem;

   class DT_DLL_VRVOSG DtOsgObserverObject : public DtObserverObject
   { 

   public:

      enum TerrainResult
      {
         TerrainResultNoData = 0,
         TerrainResultNewCenter,
         TerrainResultComplete
      };

   public:

      DtOsgObserverObject( DtDe& de, DtUniqueID id, const std::string& name="" );

      virtual ~DtOsgObserverObject();

      DtOsgObserverObject() = delete;

      DtOsgObserverObject(const DtOsgObserverObject&) = delete;

      DtOsgObserverObject& operator=(const DtOsgObserverObject&) = delete;

   public:

      virtual void tick( double simTime );

      virtual void tickAttachment();

      virtual void setModelSet( DtModelSetId modelSet );

      virtual double altitude() const;

      virtual void setNameAndRegister( const std::string& name );

      virtual void setCameraPositionAndOrientation( const osg::Vec3d& position,
         const osg::Quat& rotation );
      
      virtual void getCameraPositionAndOrientation( osg::Vec3d& position,
         osg::Quat& rotation ) const;
      
      virtual void getCameraPositionAndOrientation( DtVector& position,
         DtQuat& rotation ) const;

      static void matrixdToTaitBryan( const osg::Matrixd& mat, DtTaitBryan& tb, bool isWorld2D = false );
      static double clampUnity( double x );


      //
      //
      //
      //

      virtual void startMoveObserverRight();
      virtual void stopMoveObserverRight(); 
      virtual void moveObserverRight( double meters );

      virtual void startMoveObserverForward();
      virtual void stopMoveObserverForward();
      virtual void moveObserverForward( double meters );

      virtual void startMoveObserverUp();
      virtual void stopMoveObserverUp();
      virtual void moveObserverUp( double meters );

      virtual void startMoveObserverLeft();
      virtual void stopMoveObserverLeft();
      virtual void moveObserverLeft( double meters );

      virtual void startMoveObserverBack();
      virtual void stopMoveObserverBack();
      virtual void moveObserverBack( double meters );

      virtual void startMoveObserverDown();
      virtual void stopMoveObserverDown();
      virtual void moveObserverDown( double meters );

      virtual void startMoveLevelObserverRight();
      virtual void stopMoveLevelObserverRight();
      virtual void moveLevelObserverRight( double meters );

      virtual void startMoveLevelObserverForward();
      virtual void stopMoveLevelObserverForward();
      virtual void moveLevelObserverForward( double meters );

      virtual void startMoveLevelObserverUp();
      virtual void stopMoveLevelObserverUp();
      virtual void moveLevelObserverUp( double meters );

      virtual void startMoveLevelObserverLeft();
      virtual void stopMoveLevelObserverLeft();
      virtual void moveLevelObserverLeft( double meters );

      virtual void startMoveLevelObserverBack();
      virtual void stopMoveLevelObserverBack();
      virtual void moveLevelObserverBack( double meters );

      virtual void startMoveLevelObserverDown();
      virtual void stopMoveLevelObserverDown();
      virtual void moveLevelObserverDown( double meters );

      virtual void startMoveAttachedRight();
      virtual void stopMoveAttachedRight();
      virtual void moveAttachedRight( double meters );

      virtual void startMoveAttachedForward();
      virtual void stopMoveAttachedForward();
      virtual void moveAttachedForward( double meters );

      virtual void startMoveAttachedUp();
      virtual void stopMoveAttachedUp();
      virtual void moveAttachedUp( double meters );

      virtual void startMoveAttachedLeft();
      virtual void stopMoveAttachedLeft();
      virtual void moveAttachedLeft( double meters );

      virtual void startMoveAttachedBack();
      virtual void stopMoveAttachedBack();
      virtual void moveAttachedBack( double meters );

      virtual void startMoveAttachedDown();
      virtual void stopMoveAttachedDown();
      virtual void moveAttachedDown( double meters );

      virtual void startMoveLevelAttachedRight();
      virtual void stopMoveLevelAttachedRight();
      virtual void moveLevelAttachedRight( double meters );

      virtual void startMoveLevelAttachedForward();
      virtual void stopMoveLevelAttachedForward();
      virtual void moveLevelAttachedForward( double meters );

      virtual void startMoveLevelAttachedUp();
      virtual void stopMoveLevelAttachedUp();
      virtual void moveLevelAttachedUp( double meters );

      virtual void startMoveLevelAttachedLeft();
      virtual void stopMoveLevelAttachedLeft();
      virtual void moveLevelAttachedLeft( double meters );

      virtual void startMoveLevelAttachedBack();
      virtual void stopMoveLevelAttachedBack();
      virtual void moveLevelAttachedBack( double meters );

      virtual void startMoveLevelAttachedDown();
      virtual void stopMoveLevelAttachedDown();
      virtual void moveLevelAttachedDown( double meters );

      virtual void startMoveAttachedContextRight();
      virtual void stopMoveAttachedContextRight();
      virtual void moveAttachedContextRight( double meters );

      virtual void startMoveAttachedContextForward();
      virtual void stopMoveAttachedContextForward();
      virtual void moveAttachedContextForward( double meters );

      virtual void startMoveAttachedContextUp();
      virtual void stopMoveAttachedContextUp();
      virtual void moveAttachedContextUp( double meters );

      virtual void startMoveAttachedContextLeft();
      virtual void stopMoveAttachedContextLeft();
      virtual void moveAttachedContextLeft( double meters );

      virtual void startMoveAttachedContextBack();
      virtual void stopMoveAttachedContextBack();
      virtual void moveAttachedContextBack( double meters );

      virtual void startMoveAttachedContextDown();
      virtual void stopMoveAttachedContextDown();
      virtual void moveAttachedContextDown( double meters );

      virtual void startYawLeft();
      virtual void stopYawLeft();
      virtual void rotateYawLeft(double rads);

      virtual void startYawRight();
      virtual void stopYawRight();
      virtual void rotateYawRight(double rads);

      virtual void startPitchUp();
      virtual void stopPitchUp();
      virtual void rotatePitchUp( double rads );
      virtual void rotateFlashlightPitchUp( double rads );

      virtual void startPitchDown();
      virtual void stopPitchDown();
      virtual void rotatePitchDown( double rads );
      virtual void rotateFlashlightPitchDown( double rads );

      virtual void startRollLeft();
      virtual void stopRollLeft();
      virtual void rollLeft(double rads);

      virtual void startRollRight();
      virtual void stopRollRight();
      virtual void rollRight(double rads);

      virtual void startLevelYawLeft();
      virtual void stopLevelYawLeft();

      virtual void startLevelYawRight();
      virtual void stopLevelYawRight();

      virtual void startLevelPitchUp();
      virtual void stopLevelPitchUp();
      virtual void rotateLevelPitchUp(double rads);

      virtual void startLevelPitchDown();
      virtual void stopLevelPitchDown();
      virtual void rotateLevelPitchDown(double rads);

      virtual void startLevelRollLeft();
      virtual void stopLevelRollLeft();
      virtual void rollLevelLeft(double rads);

      virtual void startLevelRollRight();
      virtual void stopLevelRollRight();
      virtual void rollLevelRight(double rads);

      virtual void rotateLevelYawLeft( double rads );
      virtual void rotateLevelYawRight( double rads );
      virtual void rotateFlashlightYawLeft( double rads );
      virtual void rotateFlashlightYawRight( double rads );

      virtual void startLookLeft();
      virtual void stopLookLeft();
      virtual void lookLeft( double rads );

      virtual void startLookRight();
      virtual void stopLookRight();
      virtual void lookRight( double rads );

      virtual void startLookUp();
      virtual void stopLookUp();
      virtual void lookUp( double rads );

      virtual void startLookDown();
      virtual void stopLookDown();
      virtual void lookDown( double rads );

      virtual void startLookTiltRight();
      virtual void stopLookTiltRight();
      virtual void lookTiltRight( double rads );

      virtual void startLookTiltLeft();
      virtual void stopLookTiltLeft();
      virtual void lookTiltLeft( double rads );

      virtual void startOrbitingLeft();
      virtual void stopOrbitingLeft();
      virtual void orbitLeft( double rads );

      virtual void startOrbitingRight();
      virtual void stopOrbitingRight();
      virtual void orbitRight( double rads );

      virtual void startOrbitingUp();
      virtual void stopOrbitingUp();
      virtual void orbitUp( double rads );

      virtual void startOrbitingDown();
      virtual void stopOrbitingDown();
      virtual void orbitDown( double rads );

      virtual void setLocation( double x, double y, double z);

      virtual void setAttachedLocation( double x, double y, double z ) override;
      virtual void setAttachedX( double x ) override;
      virtual void setAttachedY( double y ) override;
      virtual void setAttachedZ( double z ) override;
      virtual void getAttachedPosition( double& x, double& y, double& z ) const override;

      virtual void setOrientation( double psi, double theta, double phi );

      virtual void setTopographicOrientation( double psi, double theta, double phi );

      virtual void setOrientation( double x, double y, double z, double w);

      virtual void setAttachedOrientation( double psi, double theta, double phi ) override;
      virtual void setAttachedYaw(double psi) override;
      virtual void setAttachedPitch(double theta) override;
      virtual void setAttachedRoll(double phi) override;
      virtual void getAttachedOrientation(double& psi, double& theta, double& phi) const override;

      virtual void setAttachedOrientation( double x, double y, double z,
         double w);

      void setLocalModelScalingEnabled( bool enabled );

      void setLocalModelScalingAmount( float amount );

      virtual void jumpTo( double x, double y, double z );

      virtual void jumpTo( DtUniqueID elementID );

      virtual void orientTo( double x, double y, double z );

      virtual void dragTerrain( double lastX, double lastY, double lastZ,
         double currX, double currY, double currZ );  

      virtual void dragTerrain2( double myStartDragX, double myStartDragY,
         double myStartDragZ, int deltaMouseX, int deltaMouseY );

      virtual void dragGravityUp( double windowUnits ); 
      virtual void dragGravityDown( double windowUnits );
      virtual void dragGravityLeft( double windowUnits ); 
      virtual void dragGravityRight( double windowUnits );
      virtual void scrollObserverForward( int wheelUnits );
      virtual void scrollObserverBack( int wheelUnits );
      virtual void scrollLevelObserverForward( int wheelUnits );
      virtual void scrollLevelObserverBack( int wheelUnits );

      virtual void scrollFlashlightWider( int wheelUnits );
      virtual void scrollFlashlightNarrower( int wheelUnits );

      virtual float flashlightAngle();

      //{@
      virtual void startIncreasingViewResolution();
      virtual void stopIncreasingViewResolution();
      virtual void increaseViewResolution();

      virtual void startDecreasingViewResolution();
      virtual void stopDecreasingViewResolution();
      virtual void decreaseViewResolution();

      // Sets the view resolution in meters per pixel.
      virtual void setViewResolution( double resolution);

      // Get the current view resolution.
      virtual double viewResolution() const;

      virtual void setCurrentViewMagnification( double mag );

      virtual double currentViewMagnification() const;


      //
      //

      virtual void setOrbitSpeed( double speed );

      virtual void setLinearSpeed( double speed );

      virtual void setRotationSpeed( double speed );

      virtual void setMinLinearSpeed( double minSpeed );

      virtual void setMaxLinearSpeed( double maxSpeed );

      virtual void setLinearScaledSpeedGain( double gain );

      virtual void gotoTerrainCenter( DtUniqueID terrainPatch, bool retry );

      virtual void resetAttachment();

      virtual void resetOrientation();

      virtual void resetCamera();
      virtual void level();

      virtual void stopAll();

      virtual void attachToObjects( const std::vector<DtUniqueID>& elementIds );
      virtual void setSecondaryAttachment( const std::vector<DtUniqueID>& elementIds );
      virtual void setLocationTrackAttachment( const osg::Vec3d& location );
      virtual void setLocationTrackAttachment( double x, double y, double z );

      virtual void attachToPart( int partId);
      virtual void detach();
      virtual void setAttachType( DtObserverObject::AttachType type );
      virtual void setHideModelOnAttach( bool hide );

      virtual void setUsesBoundingVolumeForAttachedOffsets(bool useBoundingVolume);

      virtual bool usesBoundingVolumeForAttachedOffsets() const;

      virtual void setAttachmentHas3DCockpit( bool cockpit );

      virtual void scaleCurrentAttachments( bool scaled );
      virtual void setOrientToTargetConstraint( bool orient );
      virtual void setOrbiting( bool orbit );
      virtual void setOrientCameraToTargetConstraint( bool orient );

      virtual void setConstrainToTerrain( bool trueFalse );
      virtual void setConstrainToCenter( bool trueFalse );

      virtual void suppressConstrainToTerrain( bool trueFalse  );

      virtual void setSpeedScaling( bool trueFalse );

      virtual void setSpeedScaledSpeed( double speed );

      virtual void getLocation(double &x, double &y, double& z) const;
      virtual void getObserverPosition(double &x, double &y, double& z) const;
      virtual void getEffectiveLocation(double &x, double &y, double& z) const;

      virtual void getObserverCameraPosition(double& x, double& y, double& z) const;

      virtual void getOrientation( double& psi, double& theta, double& phi ) const;

      virtual void getObserverCameraOrientation(double& psi, double& theta, double& phi, bool includeShake) const;

      virtual void getTopographicOrientation( double& psi, double& theta, double& phi ) const;

      virtual void getOrientation( double& x, double& y, double& z, double& w ) const;

      virtual void getFlashlightOrientation( double& x, double& y, double& z, double& w ) const;

      virtual void getObserverPlatformFront(double& x, double& y, double& z) const;

      virtual void getObserverPlatformUp(double& x, double& y, double& z) const;

      virtual void getObserverPlatformRight(double& x, double& y, double& z) const;

      virtual void getObserverCameraFront(double& x, double& y, double& z, bool includeShake) const;

      virtual void getObserverCameraUp(double& x, double& y, double& z, bool includeShake) const;

      virtual void getObserverCameraRight(double& x, double& y, double& z, bool includeShake) const;

      virtual void getCameraUp(double& x, double& y, double& z);

      virtual void getCameraFront(double& x, double& y, double& z);
      
      virtual void getCameraRight(double& x, double& y, double& z);

      virtual void setCameraShakeRotation(double x, double y, double z, double w);

      virtual void getCameraShakeRotation(double& x, double& y, double& z, double& w);;

//      virtual double calculate2DAltitude();


      virtual double heightAboveTerrainFromCurrentZoom(double magnification = 1.) const;

      virtual double altitudeFromCurrentZoom(double magnification=1.) const;

      virtual double zoomFromHeightAboveTerrain(double hat, double magnification=1) const;

      virtual double zoomFromAltitude(double altitude, double magnification=1.) const;


      virtual double zoomFromCurrentAltitude() const;

      virtual double topographicHeading() const;

      virtual void getLinearVelocity(double &x, double &y, double &z) const;

      virtual void getRotationalVelocity( double& x, double& y, double& z) const;

      virtual void setModeSetting( int setting, bool value );

      virtual void setNorthType(DtObserverObject::NorthType northType);

      virtual std::vector<DtUniqueID> currentAttachments() const;


      virtual const osg::Vec3d& locationTrackAttachmentVec3d() const;
      virtual void getLocationTrackAttachment( double& x, double& y, double& z ) const;

      virtual DtObserverObject::AttachType attachType3D() const;

      virtual DtObserverObject::AttachType attachType2D() const;

      virtual bool attachedObjectHidden() const;

      virtual bool attachmentHas3DCockpit() const;

      virtual osg::Vec3d attachedOffsetVector() const;

      virtual double attachedNearClipOffset() const;

      virtual double heightAboveTerrain() const;

      virtual double heightOfTerrain() const;

      virtual const DtIntersectorsContainer* intersectorsContainer(void) const;

      virtual DtIntersectorsContainer* intersectorsContainer(void);

   protected:

      virtual bool shouldOrientToGlobeCenter();

      virtual void adjustToGlobeCurvature();

      virtual bool shouldRotateGlobe();

      virtual void calcObserverWorldVectors();
      virtual const osg::Vec3d& observerWorldUp() const;
      virtual const osg::Vec3d& observerWorldNorth() const;
      virtual const osg::Vec3d& observerWorldEast() const;

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

      virtual osg::Vec3d& observerUp();
      virtual osg::Vec3d& observerFront();
      virtual osg::Vec3d& observerRight();
      virtual void observerBasis(osg::Vec3d& up, osg::Vec3d& front, osg::Vec3d& right);

      virtual osg::Vec3d& attachedUp();
      virtual osg::Vec3d& attachedFront();
      virtual osg::Vec3d& attachedRight();

      virtual osg::Vec3d& attachedOffsetUp();
      virtual osg::Vec3d& attachedOffsetFront();
      virtual osg::Vec3d& attachedOffsetRight();

      virtual osg::Vec3d& levelAttachedUp();
      virtual osg::Vec3d& levelAttachedFront();
      virtual osg::Vec3d& levelAttachedRight();

      virtual osg::Vec3d& levelObserverMimicUp();
      virtual osg::Vec3d& levelObserverMimicFront();
      virtual osg::Vec3d& levelObserverMimicRight();

      virtual osg::Vec3d& cameraUp();
      virtual osg::Vec3d& cameraFront();
      virtual osg::Vec3d& cameraRight();

      virtual osg::Vec3d& levelObserverUp();
      virtual osg::Vec3d& levelObserverFront();
      virtual osg::Vec3d& levelObserverRight();

      virtual void advanceOrbitLeft( double rads );
      virtual void advanceOrbitRight( double rads );
      virtual void advanceOrbitUp( double rads );
      virtual void advanceOrbitDown( double rads );

      virtual void makeLevelObserverMatrix();

      virtual void calculateLevelAttachedRotation();

      virtual void makeLevelObserverMimicMatrix();

      virtual osg::Vec3d calcWorldPositionChange();

      virtual osg::Vec3d calcMimicPositionChange();

      virtual osg::Vec3d calcAttachedPosition(const osg::Quat& attInverse, const osg::Vec3d& attachedAdvance);
      virtual osg::Vec3d calcAttachedAdvance(const osg::Quat& tetherTrackInverse);

      virtual osg::Vec3d calcFollowPositionChange();
      virtual osg::Vec3d calcSpaceFollowPositionChange();
      virtual osg::Vec3d calcTetherPositionChange();
      virtual osg::Vec3d calcTetherTrackPositionChange();

      virtual osg::Vec3d calcTrackPositionChange();
      virtual osg::Quat calcTetherTrackRotation();

      virtual osg::Quat calcFlashlightOrientationChange();
      virtual osg::Quat calcWorldOrientationChange();
      virtual osg::Quat calcTetherOrientationChange();
      virtual osg::Quat calcMimicOrientationChange();
      virtual osg::Quat calcFollowOrientationChange();

      virtual void setCurrentAttachmentsVisibility( bool visible );


      virtual void orientTo( const osg::Vec3d& target );

      virtual void orientCameraTo( const osg::Vec3d& target );

      virtual TerrainResult getTerrainCenter( const DtUniqueID& patchID, osg::Vec3d& center );

      virtual DtCoordinateConverter& coordinateConverter();
      virtual const DtCoordinateConverter& coordinateConverter() const;

      virtual void initializeAttachment();

      virtual const osg::Vec3d& scalingIntersection() const;
      virtual void getViewIntersection();

      virtual double linearSpeed();

      virtual double speedScalingGain() const;

      virtual void calcTerrainConstraint(const osg::Vec3d& prev );

      virtual bool updateAttachPositionAndOrientation();

      virtual bool getSecondaryAttachPosition( osg::Vec3d& position );

      virtual void getObserverOffsetVector( double& x, double& y, double& z ) const;
      virtual void setObserverOffsetVector( double x, double y, double z );


      virtual void getCameraFromParentOffsetVector( double& x, double& y, double& z ) const;
      virtual void getCameraFromParentRotationOffset( double& x, double& y, double& z, double& w ) const;

      virtual void getAttachedRotationOffset( double& x, double& y, double& z, double& w ) const;
      virtual void setAttachedRotationOffset( double x, double y, double z, 
         double w );

      virtual void getBoundingVolume( DtSceneObject& sceneObject,
         osg::Vec3& bvolExtents, osg::Vec3d& bvolCenter );

      virtual void getBoundingVolume( DtTerrainPatchObject& patchObject,
         osg::Vec3& bvolExtents, osg::Vec3d& bvolCenter );

      virtual void setLocation( const osg::Vec3d& location, bool suppress=true );

      virtual bool isMoving() const;
      virtual bool isRotating() const;

      virtual double computeNearClipDistance( DtSceneObject* sceneObject );
      virtual float computeLocalModelScalingAmount( DtSceneObject* sceneObject );

      virtual void calcScaledSpeed();
      virtual bool getTerrainOrPropIntersection( const osg::Vec3d& startPos, 
         const osg::Vec3d& endPos, osg::Vec3d& result, const osg::Node::NodeMask mask = ~DtOsgNodeFlags::FlagSupportOff) const;

      virtual DtSceneObject* findSceneObjectFromElement(const DtElementID& id);

      virtual DtTerrainPatchObject* findTerrainPatchObjectFromElement( DtElementID id );
      virtual DtOsgObserverObject* findObserverObjectFromElement( DtElementID id );

      virtual void getPositionAndOrientation( DtSceneObject& sceneObject, osg::Vec3d& position, 
         osg::Vec3d& orientToPosition, osg::Quat& orientation );

      virtual void getPositionAndOrientation( DtTerrainPatchObject& patchObject, osg::Vec3d& position, 
         osg::Vec3d& orientToPosition, osg::Quat& orientation );

      virtual void getPositionAndOrientation( DtOsgObserverObject& observerObject, osg::Vec3d& position, 
         osg::Vec3d& orientToPosition, osg::Quat& orientation );

      virtual void getPositionFromSceneObject( DtSceneObject& sceneObject, osg::Vec3d& position ) const;

      virtual void getPositionFromObserverObject( DtOsgObserverObject& observerObject, osg::Vec3d& position ) const;

      virtual bool getPartPositionOriFromSceneObject( DtSceneObject& sceneObject,
         int partId, osg::Vec3d& position, osg::Quat& ori ) const;

      virtual void force2D();

      virtual void dimensionChanged( bool is2D );
      virtual void setIs2D( bool is2D );

      virtual double calculate3DAltitude() const;

      virtual void calculateAltitude();

      // Sends the location of the observer on the master to all others; only used
      // if different
      virtual void synchronizeLocation( double x, double y, double z );

      // Sends the orientation of the observer on the master to all others; only used
      // if different
      virtual void synchronizeOrientation( double x, double y, double z, double w );

      virtual void calcHeightAboveTerrain(bool force=false);

      std::list<DtChannel*> findChannels();
      std::list<const DtChannel*> findChannels() const;

      virtual double frustumPixelHeight() const;

      virtual void slot_coordinateSystemChanged();

      virtual void cache3DOffsetAndRotation();

      virtual void restoreAttachOffsetsFrom3DCache();


      virtual void slot_dateChanged();

      virtual bool getAttachedToBoundingVolume(DtSceneObject* const sceneObject, osg::Vec3d& boundingVolumeCenter, osg::Vec3& boundingVolumeExtents,
         double& maxOffset, double& maxExtent);

      virtual bool setupAttachOffsetsAfterReset(DtSceneObject* const sceneObject, osg::Vec3d boundingVolumeCenter, osg::Vec3 boundingVolumeExtents,
         double maxOffset, double maxExtent);

      virtual void setupAttachOffsets(double maxExtent);

      virtual void reinitializeAfterBoundingVolumeChange();

      virtual void resetAfterBoundingVolumeChange();

   protected:

      static const double theObserverBoundingSphere;
      static const double theHeightAboveTerrainUpdatePeriod;

      static const double theMaxTerrainRetryTime; 

      // below this altitude, ignore myConstrainToCenter
      static const double theCenterConstrainHeight;

      // Zoom won't get any smaller than this
      static const double theMinViewResolution;

      // Zoom won't get any larger than this
      static const double theMaxViewResolution;


   protected:

      DtSignalConnectionManager myAttachmentBoundingVolumeSignals;

      std::vector<DtUniqueID> myCurrentAttachments;
      std::vector<DtUniqueID> mySecondaryAttachments;
      int myPartAttachment;

      double myAttachedYaw;
      double myAttachedPitch;
      double myAttachedRoll;

      bool myChanged;
      double myLastTickTime;

      //
      //
      osg::Vec3d myObserverPositionVector;
      osg::Vec3d myLastSpeedPositionVector;
      osg::Vec3d myMasterPositionVector;
      bool mySyncPending;
      bool mySyncSuppressed;
      osg::Vec3d myObserverLinearVelocityVector;
      osg::Vec3d myObserverRotationalVelocityVector;

      bool myLocalModelScalingEnabled;
      float myLocalModelScalingAmount;

      osg::Vec3d myObserverOffsetVector;

      osg::Vec3d mySavedObserverOffsetVector;

      osg::Vec3d myObserverPosition;

      osg::Vec3d myLevelObserverPosition;

      osg::Vec3d myAttachedPosition;

      osg::Vec3d myLevelAttachedPosition;

      osg::Vec3d myDragMove;

      osg::Vec3d myOrientToPosition;

      osg::Vec3d myOrbitAdvance;

      double myCurrentObserverDistance; 

      osg::Quat myAttachedRotationOffset;

      osg::Quat myObserverRotation;
      osg::Quat myMasterRotation;

      osg::Quat myFlashlightRotation;

      osg::Quat mySavedObserverRotation;

      osg::Quat myPreviousAttachedObserverRotation;

      osg::Quat myAttachedRotation;
      osg::Quat myLevelAttachedRotation;

      osg::Matrixd myLevelObserverMimicRotationMatrix;
      osg::Matrixd myLevelObserverRotationMatrix;

      osg::Vec3d my2DTo3DCachedObserverPosition;
      osg::Vec3d my2DTo3DCachedObserverOffsetVector;
      osg::Quat my2DTo3DCachedObserverRotation;
      osg::Quat my2DTo3DCachedObserverRotationOffset;

      bool myHave3DOffsetCache;
      bool myIsChangingDimension;

      //bool myGlobeObserverMode;
      bool myConstrainToCenter;


      class MotionState
      {
      public:

         enum Direction
         {
            Stopped = 0,
            Forward = 1,
            Backward = 2,
            Left = 4,
            Right = 8,
            Up = 16,
            Down = 32
         };

         MotionState()
         : myState(Stopped)
         {
         }

         inline void applyMovement(double linearDistance)
         {
            if(moving(Right)) myAdvance[0] += linearDistance;
            if(moving(Left)) myAdvance[0] -= linearDistance;
            if(moving(Forward)) myAdvance[1] += linearDistance;
            if(moving(Backward)) myAdvance[1] -= linearDistance;
            if(moving(Up)) myAdvance[2] += linearDistance;
            if(moving(Down)) myAdvance[2] -= linearDistance;
         }

         inline const osg::Vec3d& advance() const
         {
            return myAdvance;
         }

         inline void stop()
         {
            myState = Stopped;
            myAdvance.set(0.0,0.0,0.0);
            myEuler.set(0.0,0.0,0.0);
         }

         inline void clearAdvance()
         {
            myAdvance.set(0.0,0.0,0.0);
         }

         inline bool stopped()
         {
            return myState == Stopped;
         }

         inline bool moving() const
         {
            return myState != Stopped;
         }

         inline bool moving(Direction d) const
         { 
            return (myState & d) != 0; 
         }

         inline void setMoving(Direction d, bool moving) 
         { 
            myState = moving ? myState | d : myState & ~d; 
         }

         enum Angle
         {
            YawLeft = 1,
            YawRight = 2,
            PitchUp = 4,
            PitchDown = 8,
            RollLeft = 16,
            RollRight = 32
         };

         inline void applyRotation(double angle)
         {
            if(rotating(YawRight)) myEuler[0] -= angle;
            if(rotating(YawLeft))  myEuler[0] += angle;
            if(rotating(PitchUp)) myEuler[1] += angle;
            if(rotating(PitchDown))  myEuler[1] -= angle;
            if(rotating(RollRight)) myEuler[2] += angle;
            if(rotating(RollLeft))  myEuler[2] -= angle;
         }

         inline const osg::Vec3d& euler() const
         {
            return myEuler;
         }

         inline osg::Vec3d& euler()
         {
            return myEuler;
         }

         inline void level()
         {
            myEuler.set(0.0,0.0,0.0);
         }

         inline bool rotating() const
         {
            return myState != Stopped;
         }

         inline bool rotating( Angle d ) const
         {
            return (myState & d) != 0;
         }

         inline void setRotating( Angle d, bool rotating )
         {
            myState = rotating ? myState | d : myState & ~d;
         }

      protected:

         osg::Vec3d myAdvance;
         osg::Vec3d myEuler;

         unsigned char myState;
      };

      MotionState myObserverState;
      MotionState myLevelObserverState;
      MotionState myAttachedObserverState;
      MotionState myLevelAttachedObserverState;

      MotionState myRotatingState;
      MotionState myRotatingLevelState;
      MotionState myAbsoluteRotatingState;
      MotionState myAbsoluteLevelRotatingState;

      MotionState myFlashlightRotatingState;

      bool myOrbitingLeft;
      bool myOrbitingRight;
      bool myOrbitingUp;
      bool myOrbitingDown;

      double myOrbitSpeed;
      double myLinearSpeed;
      double myRotationSpeed;

      double myMaxLinearSpeed;
      double myMinLinearSpeed;
      double myLinearScaledSpeedGain;
      double mySpeedScaleSpeed;

      double mySceneCenterOffsetX;
      double mySceneCenterOffsetY;
      double mySceneCenterOffsetZ;

      //
      bool myLookingRight;
      bool myLookingLeft;
      bool myLookingUp;
      bool myLookingDown;
      bool myLookingTiltRight;
      bool myLookingTiltLeft;

      osg::Quat myFinalCameraRotation;

      osg::Vec3d myFinalCameraPositionVector;

      osg::Vec3d myCameraOffset;
      osg::Quat myCameraRotation;

      osg::Vec3d myObserverWorldUp;
      osg::Vec3d myObserverWorldNorth;
      osg::Vec3d myObserverWorldEast;

      osg::Vec3d myAttachedWorldUp;
      osg::Vec3d myAttachedWorldNorth;
      osg::Vec3d myAttachedWorldEast;

      osg::Vec3d myObserverUp;
      osg::Vec3d myObserverFront;
      osg::Vec3d myObserverRight;

      osg::Vec3d myLevelObserverUp;
      osg::Vec3d myLevelObserverFront;
      osg::Vec3d myLevelObserverRight;

      osg::Vec3d myAttachedUp;
      osg::Vec3d myAttachedFront;
      osg::Vec3d myAttachedRight;

      osg::Vec3d myLevelAttachedUp;
      osg::Vec3d myLevelAttachedFront;
      osg::Vec3d myLevelAttachedRight;

      osg::Vec3d myLevelObserverMimicUp;
      osg::Vec3d myLevelObserverMimicFront;
      osg::Vec3d myLevelObserverMimicRight;

      osg::Vec3d myAttachedOffsetUp;
      osg::Vec3d myAttachedOffsetFront;
      osg::Vec3d myAttachedOffsetRight;

      osg::Vec3d myCameraUp;
      osg::Vec3d myCameraFront;
      osg::Vec3d myCameraRight;

      DtObserverObject::AttachType my3DAttachType;

      bool myHideModelOnAttach;
      bool myAttachmentHas3DCockpit;
      bool mySpeedScaling;
      double myHeightAboveTerrainTimer;

      bool myConstrainToTerrain;

      bool myInternalSuppressConstrainToTerrain;

      bool myExternalSuppressConstrainToTerrain;

      int myOrientToTargetConstraint;
      bool myOrientCameraToTargetConstraint;
      bool myOrientToOnReset;
      bool myOrbiting;
      // force an orientation reset AFTER the next time the observer position is updated
      // Needed when making large attach jumps
      bool myForceOrientReset;

      bool myUsesBoundingVolumeForAttachedOffsets;

      bool myHaveTerrainPivot;

      bool myHaveViewIntersect;
      osg::Vec3d myViewIntersect;

      mutable bool myMutableHaveDownIntersect;
      mutable osg::Vec3d myMutableDownIntersect;

      osg::Vec3d myAttachPosition;

      double myLastAttachedBvolDiameter;
      double myLastAttachBvolOffset;

      osg::Vec3d myPreviousPositionVector;
      osg::Vec3d myPreviousOffsetVector;

      double myAltitude;

      bool myViewResolutionIncreasingState;
      bool myViewResolutionDecreasingState;
      double myViewResolution;

      double myCurrentViewMagnification;
      double myLastViewMagnification;

      typedef std::unordered_map<DtElementID, bool>  ElementVisibilityMap;
      ElementVisibilityMap myPendingVisibilityState;

      // Paged terrain initialization
      bool myGotoTerrainCenterPending;
      double myNextGotoTerrainCenterTime;
      double myStartGotoTerrainCenterTime;
      DtUniqueID myPendingTerrainPatchId;
      osg::Vec3d myPreviousTerrainCenter;
      double myHeightAboveTerrain;
      double myHeightOfTerrain;

      // Used for speed scaling, this is the same as myHeightAboveTerrain
      // when unattached, but the distance from the attached entity when
      // attached
      double mySpeedScaleHeightEquivalent;

      // curvature adjustment
      double myCurvatureAdjustment;
      bool myMovedSinceLastHAT;
      float myFlashlightAngle;

      osg::Quat myCameraShakeRot;

      osg::Vec3d myLocationAttachPoint;

      DtIntersectorsContainer* myIntersectors = nullptr;

      DtSignalConnectionManager myConnections;

      DtCoordinateSystem* myCoordinateSystem = nullptr;
   };

}