DtObserverObject.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtUniqueID.h>

#include <string>
#include <vector>
#include <map>

namespace makVrv
{

   class DtDe;
   class DtInputDriver;
   class DtSensor;

   class DT_DLL_VRVCORE DtObserverObject
   { 

   public:

      typedef std::map<int, bool> ModeSettingsMap;

      enum AttachType
      {
         AttachTypeTether,
         AttachTypeMimic,
         AttachTypeFollow,
         AttachTypeTrack,
         AttachTypeTetherTrack,
         AttachTypeMimicTrack,
         AttachTypeModelView,
         AttachTypeSpaceFollow,
         AttachTypeTetherLocationTrack,
         AttachTypeMimicLocationTrack
      };

      enum SpeedScalingMode
      {
         SpeedScalingAgl,
         SpeedScalingMsl
      };

      enum NorthType
      {
         NorthTypeTrueNorth,
         NorthTypeMagneticNorth,
         NorthTypeGridNorth
      };

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

      virtual ~DtObserverObject();
      
      virtual const std::string& name() const;
      
      virtual bool is2D() const;
      
      virtual void setIs2D( bool is2D );

      virtual bool displaySky() const;
      
      virtual void setDisplaySky( bool hasSky );

      virtual bool dynamicLights() const;

      virtual void setDynamicLights( bool enabled );

      virtual bool dynamicOcean() const;

      virtual void setDynamicOcean( bool enabled );

      virtual bool isScaling() const;

      virtual void setScaling(bool scale);

      virtual double scaleFactor() const;
      
      virtual void setScaleFactor( double scaleFactor );

      virtual void setMaxModelScaleFactor(double maxModelScaleFactor);

      virtual double maxModelScaleFactor() const;

      void setLodScaleCenterEnabled(bool enabled);
      bool lodScaleCenterEnabled() const;

      void setLodScaleCenterMagMinLimit(double limit);
      double lodScaleCenterMagMinLimit() const;

      virtual DtObserverObject::NorthType northType() const;

      virtual void setNorthType(DtObserverObject::NorthType northType);

      virtual const std::string& scaleType() const;

      virtual void setScaleType(const std::string& scaleType);

      virtual int modelSet() const;

      virtual void setModelSet( int modelSet );

      virtual void setSpeedScalingMode( SpeedScalingMode mode );

      virtual SpeedScalingMode speedScalingMode() const;

      virtual void setSpeedScalingMslModeOffset( double offset );

      virtual double speedScalingMslModeOffset() const;

      void setScalingIntersectionTerrainSkinOnly(bool enabled);
      bool scalingIntersectionTerrainSkinOnly() const;

      virtual void clearModeSettings();

      virtual void setModeSetting( int setting, bool value );

      virtual bool modeSetting( int setting ) const;

      virtual const ModeSettingsMap& modeSettings() const;

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

      virtual void tick( double ) {}

      virtual void setTerrainIsGlobal(bool global);

      virtual double altitude() const = 0;

      virtual double heightAboveTerrain() const = 0;

      virtual double viewResolution() const { return 1.; };

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


      virtual void setCurrentViewMagnification( double mag ) = 0;

      virtual double currentViewMagnification() const = 0;

      //
      //
      //
      //
      
      virtual void startMoveObserverRight() {}
      virtual void stopMoveObserverRight() {} 
      virtual void moveObserverRight( double ) {}
      
      virtual void startMoveObserverForward() {}
      virtual void stopMoveObserverForward() {}
      virtual void moveObserverForward( double ) {}
      
      virtual void startMoveObserverUp() {}
      virtual void stopMoveObserverUp() {}
      virtual void moveObserverUp( double ) {}
     
      virtual void startMoveObserverLeft() {}
      virtual void stopMoveObserverLeft() {}
      virtual void moveObserverLeft( double ) {}
        
      virtual void startMoveObserverBack() {}
      virtual void stopMoveObserverBack() {}
      virtual void moveObserverBack( double ) {}
      
      virtual void startMoveObserverDown() {}
      virtual void stopMoveObserverDown() {}
      virtual void moveObserverDown( double ) {}
  
      virtual void startMoveLevelObserverRight() {}
      virtual void stopMoveLevelObserverRight() {}
      virtual void moveLevelObserverRight( double ) {}
      
      virtual void startMoveLevelObserverForward() {}
      virtual void stopMoveLevelObserverForward() {}
      virtual void moveLevelObserverForward( double ) {}
      
      virtual void startMoveLevelObserverUp() {}
      virtual void stopMoveLevelObserverUp() {}
      virtual void moveLevelObserverUp( double ) {}
     
      virtual void startMoveLevelObserverLeft() {}
      virtual void stopMoveLevelObserverLeft() {}
      virtual void moveLevelObserverLeft( double ) {}
      
      virtual void startMoveLevelObserverBack() {}
      virtual void stopMoveLevelObserverBack() {}
      virtual void moveLevelObserverBack( double ) {}
      
      virtual void startMoveLevelObserverDown() {}
      virtual void stopMoveLevelObserverDown() {}
      virtual void moveLevelObserverDown( double ) {}
      
      virtual void startMoveAttachedRight() {}
      virtual void stopMoveAttachedRight() {} 
      virtual void moveAttachedRight( double ) {}
      
      virtual void startMoveAttachedForward() {}
      virtual void stopMoveAttachedForward() {}
      virtual void moveAttachedForward( double ) {}
      
      virtual void startMoveAttachedUp() {}
      virtual void stopMoveAttachedUp() {}
      virtual void moveAttachedUp( double ) {}
     
      virtual void startMoveAttachedLeft() {}
      virtual void stopMoveAttachedLeft() {}
      virtual void moveAttachedLeft( double ) {}
        
      virtual void startMoveAttachedBack() {}
      virtual void stopMoveAttachedBack() {}
      virtual void moveAttachedBack( double ) {}
      
      virtual void startMoveAttachedDown() {}
      virtual void stopMoveAttachedDown() {}
      virtual void moveAttachedDown( double ) {}
  
      virtual void startMoveLevelAttachedRight() {}
      virtual void stopMoveLevelAttachedRight() {}
      virtual void moveLevelAttachedRight( double ) {}
      
      virtual void startMoveLevelAttachedForward() {}
      virtual void stopMoveLevelAttachedForward() {}
      virtual void moveLevelAttachedForward( double ) {}
      
      virtual void startMoveLevelAttachedUp() {}
      virtual void stopMoveLevelAttachedUp() {}
      virtual void moveLevelAttachedUp( double ) {}
     
      virtual void startMoveLevelAttachedLeft() {}
      virtual void stopMoveLevelAttachedLeft() {}
      virtual void moveLevelAttachedLeft( double ) {}
      
      virtual void startMoveLevelAttachedBack() {}
      virtual void stopMoveLevelAttachedBack() {}
      virtual void moveLevelAttachedBack( double ) {}
      
      virtual void startMoveLevelAttachedDown() {}
      virtual void stopMoveLevelAttachedDown() {}
      virtual void moveLevelAttachedDown( double ) {}
         
      virtual void startMoveAttachedContextRight() {}
      virtual void stopMoveAttachedContextRight() {}
      virtual void moveAttachedContextRight( double ) {}
      
      virtual void startMoveAttachedContextForward() {}
      virtual void stopMoveAttachedContextForward() {}
      virtual void moveAttachedContextForward( double ) {}
      
      virtual void startMoveAttachedContextUp() {}
      virtual void stopMoveAttachedContextUp() {}
      virtual void moveAttachedContextUp( double ) {}
     
      virtual void startMoveAttachedContextLeft() {}
      virtual void stopMoveAttachedContextLeft() {}
      virtual void moveAttachedContextLeft( double ) {}
      
      virtual void startMoveAttachedContextBack() {}
      virtual void stopMoveAttachedContextBack() {}
      virtual void moveAttachedContextBack( double ) {}
      
      virtual void startMoveAttachedContextDown() {}
      virtual void stopMoveAttachedContextDown() {}
      virtual void moveAttachedContextDown( double ) {}
     
      virtual void startYawLeft() {}
      virtual void stopYawLeft() {}
      virtual void rotateYawLeft( double rads ) {}
      virtual void rotateFlashlightYawLeft( double rads ) {}
      
      virtual void startYawRight() {}
      virtual void stopYawRight() {}
      virtual void rotateYawRight( double rads ) {}
      virtual void rotateFlashlightYawRight( 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 rotateLevelYawLeft( double rads ) {}
      
      virtual void startLevelYawRight() {}
      virtual void stopLevelYawRight() {}
      virtual void rotateLevelYawRight( double rads ) {}
      
      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 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 level() {}
     
      virtual void setLocation( double x, double y, double z ) {}
       
      virtual void jumpTo( double x, double y, double z ) {}
      
      virtual void jumpTo( DtUniqueID id ) {}
      
      virtual void orientTo( double x, double y, double z ) {} // = 0;
            
      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 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 resetCamera() {}

      //
      //
      //
      //
      
      virtual void setOrbitSpeed( double speed ) {}
      
      virtual void setSpeedScaledSpeed( double speed ) {}
       
      virtual void setLinearSpeed( double speed ) {}
       
      virtual void setRotationSpeed( double speed ) {}

      virtual void setMaxLinearSpeed( double maxSpeed ) {}
      
      virtual void setMinLinearSpeed( double minSpeed ) {}

      virtual void setLinearScaledSpeedGain( double gain ) {}
     
      virtual void resetOrientation() {}
      
      virtual void gotoTerrainCenter( DtUniqueID terrainPatch, bool retry ) {}     
      
      virtual void resetAttachment() {}     
      
    
      virtual void stopAll() {}
      
      virtual void attachToObjects( const std::vector<DtUniqueID>& ids ) {}      
      virtual void setSecondaryAttachment( const std::vector<DtUniqueID>& ids  ) {}
      virtual void setLocationTrackAttachment( double x, double y, double z ) {}

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

      virtual void getLocationTrackAttachment( double& x, double& y, double& z )
         const = 0;

      virtual void attachToPart( int partId) {}      
      virtual void detach() {}
      
      virtual void setSpeedScaling( bool trueFalse ) {}
      
      virtual void setConstrainToTerrain( bool trueFalse ) {}
      virtual void setConstrainToCenter( bool trueFalse ) {}
     
      virtual void increaseViewResolution() {}
      virtual void startIncreasingViewResolution() {}
      virtual void stopIncreasingViewResolution() {}
      virtual void decreaseViewResolution() {}
      virtual void startDecreasingViewResolution() {}
      virtual void stopDecreasingViewResolution() {}
      virtual void setViewResolution( double resolution ) {}
      
      virtual void suppressConstrainToTerrain( bool trueFalse  ) {}
      virtual void setAttachType( DtObserverObject::AttachType type ) {}
      virtual DtObserverObject::AttachType attachType();

      virtual void setHideModelOnAttach( bool hide ) {}

      virtual void setUsesBoundingVolumeForAttachedOffsets(bool useBoundingVolume) = 0;
      virtual bool usesBoundingVolumeForAttachedOffsets() const = 0;

      virtual void setAttachmentHas3DCockpit( bool cockpit ) {}

      virtual void setOrientToTargetConstraint( bool orient ) {}
      virtual void setOrbiting( bool orient ) {}
      virtual void setOrientCameraToTargetConstraint( bool orient ) {}

      virtual void setFlashlightEnabled(bool enabled);

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

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

      virtual bool flashlightOn() const;

      virtual void getLocation(double &x, double &y, double& z) const
      {
         x = y = z = 0.;
      }

      virtual void getEffectiveLocation(double &x, double &y, double& z) const
      {
         x = y = z = 0.;
      }

      virtual void getObserverCameraPosition(double& x, double& y, double& z) const
      {
         x = y = z = 0;
      }

      virtual void getOrientation( double& psi, double& theta, double& phi ) const
      {
         psi = theta = phi = 0.; 
      }

      virtual void getTopographicOrientation( double& psi, double& theta, double& phi ) const
      {
         psi = theta = phi = 0.; 
      }

      virtual void getLinearVelocity( double &x, double &y, double &z ) const
      {
         x = y = z = 0;
      }

      virtual void getRotationalVelocity( double& x, double& y, double& z) const
      { 
         x = y = z = 0.; 
      }

      virtual void getObserverOffsetVector( double& x, double& y, double& z ) const
      {
         x = y = z = 0.;
      }

      virtual void getCameraFromParentOffsetVector( double& x, double& y, double& z ) const 
      {
         x = y = z = 0.;
      }
      virtual void getCameraFromParentRotationOffset( double& x, double& y, double& z, double& w ) const
      {
         x = y = z = w =0.;
      }

      virtual double linearSpeed() 
      { 
         return 0.; 
      }

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

      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) = 0;
      virtual void setAttachedYaw(double psi) = 0;
      virtual void setAttachedPitch(double theta) = 0;
      virtual void setAttachedRoll(double phi) = 0;
      virtual void getAttachedOrientation(double& psi, double& theta, double& phi) const = 0;

      virtual void setLocalModelScalingEnabled( bool enabled ) {}

      virtual void setLocalModelScalingAmount( float amount ) {}

      virtual void setObserverOffsetVector( double x, double y, double z ) {}

      virtual void getAttachedRotationOffset( double& x, double& y, double& z, double& w ) const
      {
         x = y = z = 0.;
         w = 1.;
      }

      virtual void getOrientation( double& x, double& y, double& z, double& w ) const
      {
         x = y = z = 0.;
         w = 1.;
      }

      // Get the orientation of the camera rotated by the orientation of the observer
      virtual void getObserverCameraOrientation(double& psi, double& theta, double& phi, bool includeShake = true) const
      {
         psi = theta = phi = 0.;
      }

      virtual void setAttachedRotationOffset( double x, double y, double z, 
         double w ) {}
      
      virtual void getObserverPlatformFront(double& x, double& y, double& z) const
      {
         x = y = z = 0.;
      }

      virtual void getObserverPlatformUp(double& x, double& y, double& z) const
      {
         x = y = z = 0.;
      }

      virtual void getObserverPlatformRight(double& x, double& y, double& z) const
      {
         x = y = z = 0.;
      }
      
      virtual void getObserverCameraFront(double& x, double& y, double& z, bool includeShake=true) const
      {
         x = y = z = 0.;
      }

      virtual void getObserverCameraUp(double& x, double& y, double& z, bool includeShake = true) const
      {
         x = y = z = 0.;
      }

      virtual void getObserverCameraRight(double& x, double& y, double& z, bool includeShake = true) const
      {
         x = y = z = 0.;
      }

      virtual void getCameraUp(double& x, double& y, double& z)
      {
         x = y = z = 0.;
      }

      virtual void getCameraFront(double& x, double& y, double& z)
      {
         x = y = z = 0.;
      }


      virtual void getCameraRight(double& x, double& y, double& z)
      {
         x = y = z = 0.;
      }

      virtual bool isMoving() const { return false; }

      virtual double topographicHeading() const
      {
            return 0.0;
      }

      bool isGlobalTerrain() const
      {
         return myTerrainIsGlobalFlag;
      }

      // 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 setSensor(const std::string& sensorName);

      virtual DtSensor* findSensor() const;

      virtual void disableSensor();

      virtual void setLodScale(float lodScale);

      virtual float lodScale();

   private:

      DtObserverObject( const DtObserverObject& );

      DtObserverObject& operator=( const DtObserverObject& );

   protected:

      DtDe& myDe;
      std::string myName;
      bool myIs2D;
      double myScaleFactor;
      int myModelSet;
      std::string myScaleType;
      bool myTerrainIsGlobalFlag;
      ModeSettingsMap myModeSettingsMap;
      bool myFlashlightOn;
      DtSensor* mySensor;
      SpeedScalingMode mySpeedScalingMode;
      double mySpeedScalingMslModeOffset;
      bool myScalingIntersectionTerrainSkinOnly;
      DtUniqueID myUniqueId;
      double myMaxModelScaleFactor;
      bool myLodScaleCenterEnabled;
      double myLodScaleCenterMagMinLimit;
      DtObserverObject::NorthType myNorthType;
      DtObserverObject::AttachType myAttachType;
      float myLodScale;
   };
}