DtObserver.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/DtElementAttributeManager.h>
#include <vrvCore/DtElementData.h>
#include <vrvCore/DtObserverObject.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <matrix/vlVector.h>

#include <makArchives/DtObserverStateRecord.h>


class DtTaitBryan;

namespace makVrv
{   
   class DtObserverObjectAgent;
   class DtDe;
   class DtAgentManagerInterface;
   class DtObserverConfiguration;
   class DtSensor;
   class DtOceanLayer;
   class DtQuat;
   class DtCameraShake;
   class DtChannelConfiguration;

   class DT_DLL_VRVCORE DtObserver
   {
   public:
      
      typedef std::vector<DtElementID> ElementList;

      DtObserver(DtDe& de, DtAgentManagerInterface& sceneInterface, 
         const DtObserverConfiguration& config );

      virtual ~DtObserver();

      inline DtDe& de()
      {
         return myDe;
      }
      
      DtObserverObjectAgent& agent();

      const DtObserverObjectAgent& agent() const;

      //@name Saved View loading / setting functions.

      bool getRecord(makArchives::DtObserverStateRecord& recOut) const;

      void setFromRecord(const makArchives::DtObserverStateRecord& rec);

      bool getRecord(makArchives::DtObserverSettingsRecord& recOut) const;

      void setFromRecord(const makArchives::DtObserverSettingsRecord& rec);

      makArchives::DtObserverStateRecord getCachedObserverStateRecord() const;

      bool hasInitialLocation() const;

      bool projectionIs2D() const;
      void setProjectionIs2D( bool is2d );


      const std::string& name() const;
      void setName( const std::string& name ); 
      

      int observerMode() const;   
      bool setObserverMode( int observerMode );

      double viewResolution() const;

      void setViewResolution(double resolution);

      void setViewResolutionFromHeightAboveTerrain(double hat);

      double viewMagnification() const;

      void setViewMagnification(double magnficationFactor);

      void setLodScale(double lodScale);

      double lodScale() const;

      void setPaperMapLayer(const std::string& paperMapLayer);

      std::string paperMapLayer() const;

      DtObserverConfiguration& configuration();
      const DtObserverConfiguration& configuration() const;

      bool inUse( const std::string& channelKeyToIgnore = "" ) const;

      //@name Attachment functions.

      void attachToNextElement();

      void attachToPreviousElement();
     
      bool isAttached(DtElementID) const;

      bool isPrimaryAttached(DtElementID) const;

      bool isSecondaryAttached(DtElementID) const;

      void setPrimaryAttachment(const ElementList& elements);
      void setPrimaryAttachment(DtElementID element);

      void setSecondaryAttachment(const ElementList& element);
      void setSecondaryAttachment(DtElementID element);

      void setLocationTrackAttachment( double x, double y, double z );

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

      void setPartAttachment(int partId);

      int partAttachment() const;

      void detach();

      bool attached() const;

      bool tracking() const;

      const ElementList& primaryAttachments() const; 

      const ElementList& secondaryAttachments() const; 
      
      void setHideModelOnAttach( bool hide );
      bool hideModelOnAttach() const;


      void setAttachmentHas3DCockpit( bool cockpit);
      bool attachmentHas3DCockpit() const;

      void setAttachType( DtObserverObject::AttachType type );
      DtObserverObject::AttachType attachType() const;      
            
      void setOrientToTargetConstraint( bool orient );
      bool orientToTargetConstraint() const;

      DtElementID lastSingleAttached() const;

      bool haveLastSingleAttached() const;


      //@name Movement functions

      void reset();

      void setAllowReset(bool b);

      bool allowReset() const;

      void setAllowAttach(bool b);

      bool allowAttach() const;

      void setAllowDetach(bool b);

      bool allowDetach() const;

      void centerOnTerrain();

      void centerOnTerrain( const DtUniqueID& terrainPatch );
      
      void suppressConstrainToTerrain(  bool trueFalse );
      
      void setConstrainToCenter( bool trueFalse );
      void toggleConstrainToCenter();
      bool constrainToCenter() const;                      

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

      DtVector location() const;

      DtVector observerCameraPosition() const;
      
      void setLocation( double x, double y, double z );      

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

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

      void setOrientation( double psi, double theta, double phi );
  
      void setTopographicOrientation( double psi, double theta, double phi );
      
      void getOrientation( double& x, double& y, double& z, double& w ) const;

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

      DtTaitBryan observerCameraOrientation(bool includeShake=true) const;

      virtual DtVector observerPlatformFront() const;

      virtual DtVector observerPlatformUp() const;

      virtual DtVector observerPlatformRight() const;
            
      virtual DtVector observerCameraFront(bool includeShake=true) const;

      virtual DtVector observerCameraUp(bool includeShake = true) const;

      virtual DtVector observerCameraRight(bool includeShake = true) const;
      
      void moveUnit(const DtVector& direction);

      void rotateUnit(const DtTaitBryan& rotation);

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

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

      bool observerObjectMoving() const;

      double observerAltitude() const;

      //@name Attached Movement functions
      
      void setAttachedLocation( double x, double y, double z );
      void setAttachedX( double x );
      void setAttachedY( double y );
      void setAttachedZ( double z );

      void setAttachedOrientation( double psi, double theta, double phi );
      void setAttachedYaw(double psi);
      void setAttachedPitch(double theta);
      void setAttachedRoll(double phi);

      void setLocalModelScalingEnabled( bool enabled );

      void setLocalModelScalingAmount( float amount );


      //@name Speed functions

      void setOrbitSpeedGain( int gain, bool forwardToObserverModeManager = true );

      int orbitSpeedGain() const;

      int orbitSpeedGainFromSpeed( double speed ) const;

      void setRotationSpeedGain( int gain, bool forwardToObserverModeManager = true );
      int rotationSpeedGain() const;

      void setLinearSpeedGain( int gain );
      int linearSpeedGain() const;

      void setLinearScaledSpeedGain( int gain, bool forwardToObserverModeManager = true );
      int linearScaledSpeedGain() const;

      void setLinearUnscaledSpeedGain( int gain, bool forwardToObserverModeManager = true );
      int linearUnscaledSpeedGain() const;

      void setGainPrecision( int amt, bool forwardToObserverModeManager = true );
      int gainPrecision() const;

      void setModelScaleFactor( double modelScaleFactor, bool forwardToObserverModeManager = true );
      double modelScaleFactor() const;

      void setModelScaleType( const std::string& modelScaleType, bool forwardToObserverModeManager = true );
      const std::string& modelScaleType() const;

      void setMaxModelScaleFactor(double maxModelScaleFactor, bool forwardToObserverModeManager = true);
      double maxModelScaleFactor() const;

      void setSpeedScalingMode( DtObserverObject::SpeedScalingMode mode,
         bool forwardToObserverModeManager = true );
      DtObserverObject::SpeedScalingMode speedScalingMode() const;

      void setLodScaleCenterEnabled(bool enabled, bool forwardToObserverModeManager = true);
      bool lodScaleCenterEnabled() const;

      void setLodScaleCenterMagMinLimit(double limit, bool forwardToObserverModeManager = true);
      double lodScaleCenterMagMinLimit() const;

      void setNorthType(DtObserverObject::NorthType northType, bool forwardToObserverModeManager = true);

      DtObserverObject::NorthType northType() const;

      void setSpeedScalingMslModeOffset(double offset,
         bool forwardToObserverModeManager = true );
      double speedScalingMslModeOffset() const;

      void setOrbitSpeed( double speed );
      double orbitSpeed() const;

      void setRotationSpeed( double speed );
      double rotationSpeed() const;

      void setLinearSpeed( double speed );
      double linearSpeed() const;


      virtual void toggleFlashlight();

      virtual DtCameraShake* cameraShake();

      virtual bool setCameraShake(const std::string& shakeType);

      virtual void setCameraShakeRotation(const DtQuat& rotQuat) const;

      //@name Sensor functions
      virtual void setSensor(const std::string& sensorName);

      virtual std::string findSensor();

      virtual void disableSensor();

      virtual void slot_sensorRemoved(DtSensor* sensor);

      // Called by the input driver before any mouse or keyboard input is processed for the
      // frame, to sync local and remote observers.
      virtual void synchronize();

      boost::signalslib::signal<void(const std::string&, DtUniqueID)> signal_objectAttached;

      boost::signalslib::signal<void(const std::string&)> signal_objectsDetached;

      boost::signalslib::signal<void(DtObserver*, int)> signal_observerModeChanged;

      boost::signalslib::signal<void(DtObserver*, int)> signal_linearScaledSpeedGainChanged;
      
      boost::signalslib::signal<void(DtObserver*, int)> signal_linearUnscaledSpeedGainChanged;
      
      boost::signalslib::signal<void(DtObserver*, int)> signal_rotationSpeedGainChanged;
      
      boost::signalslib::signal<void(DtObserver*, int)> signal_orbitSpeedGainChanged;
      
      boost::signalslib::signal<void(DtObserver*, int)> signal_gainPrecisionChanged;
      
      boost::signalslib::signal<void(DtObserver*, double)> signal_modelScaleFactorChanged;

      boost::signalslib::signal<void(DtObserver*, std::string)> signal_modelScaleTypeChanged;

      boost::signalslib::signal<void(DtObserver*, double)> signal_viewMagnificationChanged;

      boost::signalslib::signal<void(DtObserver*, double)> signal_lodScaleChanged;

      boost::signalslib::signal<void(DtObserver*, std::string)> signal_paperMapLayerChanged;

      boost::signalslib::signal<void (DtObserver*, 
         DtObserverObject::SpeedScalingMode scalingMode)> 
         signal_speedScalingModeChanged;

      boost::signalslib::signal<void (DtObserver*, double offset)> 
         signal_speedScalingMslModeOffsetChanged;
      
      boost::signalslib::signal<void(DtObserver*, bool)> signal_lodScaleCenterEnabledChanged;
      
      boost::signalslib::signal<void(DtObserver*, double)> signal_lodScaleCenterMagMinLimitChanged;

      boost::signalslib::signal<void(DtObserver*, DtObserverObject::NorthType northType)>
         signal_northTypeChanged;

      boost::signalslib::signal<void (DtSensor*)> signal_sensorChanged;

      boost::signalslib::signal<void ()> signal_terrainChanged;
           
      void getObserverOffsetVector( double& x, double& y, double& z ) const;
      void getObserverRotationOffset( double& x, double& y, double& z, double& w ) const;
      

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


      virtual void setUsesBoundingVolumeForAttachedOffsets(bool useBoundingVolume);

      virtual bool usesBoundingVolumeForAttachedOffsets() const;

   protected:

      void slot_terrainCleared();
      void slot_oceanLayerAdded(const DtOceanLayer&);
      void slot_oceanLayerDeleted(const std::string&);

      void updateGlobalTerrainFlag(bool flag);

      double calcLinearSpeed() const;
      double calcRotationSpeed() const;
      double calcOrbitSpeed() const;     

      void setObserverOffsetVector( double x, double y, double z );
      
      void setObserverRotationOffset( double x, double y, double z, double w );

      void getDisplayNamesFromUniqueIds(const std::vector<DtUniqueID>& idsIn, 
         std::set<std::string>& displayNamesOut) const;
      bool getUniqueIdsFromDisplayNames(const std::set<std::string>& displayNamesIn, 
         std::vector<DtUniqueID>& idsOut) const;

      makArchives::DtObserverSettingsRecord::AttachType convertObserverAttachType(
         DtObserverObject::AttachType type) const;
      DtObserverObject::AttachType convertObserverSettingsAttachType(
         makArchives::DtObserverSettingsRecord::AttachType type) const;

      void connectToElementDataSignals();
      void disconnectFromElementDataSignals();
                
      void setModeSpecificObserverObjectData();   
         
      virtual void slot_onElementsAdded( const DtElementData::ElementList& elements );


      virtual void attachToObjects(const ElementList& objects);

      virtual void slot_attachNextTick(const ElementList objects);

      virtual bool sceneObjectsAvailable(const ElementList& elements);

      virtual void slot_onElementAttributesChanged( 
         const DtElementAttributeManager::EntryAttributesList& attributes );
      
      void slot_completeAttachment();

      void slot_observerModeModelSetChanged( int observerMode );
      void slot_observerModeSensorChanged( int observerMode );
      void slot_observerModeIs2DChanged( int observerMode );
      void slot_observerModeKeyMapChanged( int observerMode );
      void slot_observerModeGainPrecisionChanged( int observerMode );
      void slot_observerModeOrbitSpeedGainChanged( int observerMode );
      void slot_observerModeRotationSpeedGainChanged( int observerMode );
      void slot_observerModeLinearScaledSpeedGainChanged( int observerMode );
      void slot_observerModeLinearUnscaledSpeedGainChanged( int observerMode );
      void slot_observerModeModelScaleFactorChanged( int observerMode );
      void slot_observerModeModelScaleTypeChanged( int observerMode );
      void slot_observerModeSpeedScalingModeChanged( int observerMode );
      void slot_observerModeSpeedScalingMslModeOffsetChanged( int observerMode );
      void slot_observerModeLodScaleCenterEnabledChanged(int observerMode);
      void slot_observerModeLodScaleCenterMagMinLimitChanged(int observerMode);
      void slot_observerModeNorthTypeChanged(int observerMode);
      void slot_observerModeSettingChanged(int observerMode, int settingKey);
      void slot_observerModeAdded( int observerMode );

      // Called when the DE raises the channel configuration modified signal.  If a channel
      // config has it's lod scale modified, the observer will modify all the other channels that
      // it controls to keep them in sync. 
      void slot_channelModified(const DtChannelConfiguration& config);

      void attachTo( bool afterTrue );

   protected:

      static const double theMoveStepSize;

      DtDe& myDe;
      DtSignalConnectionManager myConnections;
      DtObserverObjectAgent* myObserverObjectAgent;
      DtObserverConfiguration* myConfiguration;
      makArchives::DtObserverStateRecord myCachedObserverStateRecord;      
      int myObserverMode;     
      bool myHideModelOnAttach;
      bool myAttachmentHas3DCockpit;
      DtObserverObject::AttachType myAttachType;
      std::vector<DtUniqueID> myCurrentAttachments;
      std::vector<DtUniqueID> mySecondaryAttachments;
      DtUniqueID myLastSingleAttached;
      unsigned int myPartId;
      bool myOrientToTargetConstraint;
      bool myConstrainToCenter;
      bool myConnectedToElementDataSignals;      
      bool myAllowReset;
      bool myAllowAttach;
      bool myAllowDetach;
      bool myHasInitialLocation;
      bool myFlashlightEnabled;
      double myViewMagnification;
      float myLodScale;
      DtSensor* mySensor;
      DtCameraShake* myCameraShake;
      bool myProjectionIs2D;
      std::string myPaperMapLayer;
   };
}