DtCigiBaseEntity.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2020 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/


#pragma once

#include <vrvCigi/vrvCigi.h>

#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtGroundClampingUpdater.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <matrix/geodeticCoord.h>
#include <matrix/vlTaitBryan.h>

#include <vlpi/entityType.h>

#include <string>

namespace makVrv
{
   class DtAgentManagerInterface;
   class DtCigiConnection;
   class DtModelAgent;
   class DtSceneObjectAgent;
   class DtGroundClampingUpdaterAgent;
   class DtDeadReckonUpdaterAgent;
   class DtEmbarkationUpdaterAgent;
   class DtSceneObject;
   class DtDeadReckonUpdater;


   class DT_DLL_VRVCIGI DtCigiBaseEntity
   {
   public:
      DtCigiBaseEntity(DtCigiConnection& connection,
         DtAgentManagerInterface& sceneInterface, int entityId,
         int entityType);

      virtual ~DtCigiBaseEntity();

      virtual DtUniqueID uniqueId() const;

      virtual DtUniqueID elementId() const;

      virtual int cigiId() const;

      virtual void init();

      virtual void uninit();

      virtual void restart();

      virtual void restartRequest();

      virtual int entityType() const;

      virtual bool extendedEntityTypeOn() const;

      virtual void setExtendedEntityTypeOn(bool onOff);

      virtual void setExtendedEntityType(DtEntityType& entityType);

      virtual void setVisible(bool yesNo);

      virtual bool isVisible() const;

      virtual void setDeadReckoningOn(bool onOff);

      virtual bool isDeadReckoning() const;

      virtual void setPosition(const DtGeodeticCoord& pos, bool force=false);

      virtual const DtGeodeticCoord& position() const;

      virtual const DtVector& localPosition() const;

      virtual void setOrientation(const DtTaitBryan& orientation, bool force=false);

      virtual const DtTaitBryan& orientation() const;

      virtual const DtTaitBryan& localOrientation() const;

      virtual const DtTaitBryan& geocentricOrientation() const;

      virtual void setLinearRate(const DtVector& rate, bool useWorldCoordinates, bool force=false);

      virtual const DtVector& linearRate() const;

      virtual void setAngularRate(const DtVector& rate, bool useWorldCoordinates, bool force=false);

      virtual const DtVector& angularRate() const;


      virtual void setRelativeTo(DtCigiBaseEntity* parent);

      virtual void setRelativePosition(const DtVector& pos);

      virtual void setRelativeOrientation(const DtTaitBryan& orient);
      
      virtual bool isEmbarked() const;

      virtual int embarkedParentId() const;

      virtual const DtVector& relativePosition() const;

      virtual const DtTaitBryan& relativeOrientation() const;

      virtual void slot_deadReckoningAllowed(bool allowed);

      virtual void setAlpha(int alpha);

      virtual int alpha() const;

      virtual void setInheritAlpha(bool inherit);

      virtual bool isInheritingAlpha() const;

      virtual void slot_alphaChanged(int alpha, DtUniqueID id);

      virtual void slot_entityToBeDeleted(int cigiEntityId);

      virtual void setGroundClampingOn( DtGroundClampingUpdater::GroundClampingMode clampType );
      
      virtual DtGroundClampingUpdater::GroundClampingMode groundClampingType() const;

      virtual void setArtPartTranslation(int partId, float xOffset, float yOffset,
         float zOffset, bool xEnable, bool yEnable, bool zEnable);
     
      virtual bool getArtPartTranslation( int partId, DtVector& translation );

      virtual void setArtPartOrientation(int partId, float yaw, float pitch, float roll,
         bool yawEnable, bool pitchEnable, bool rollEnable);

      // Get the art part orientation from a specified CIGI part id.
      virtual bool getArtPartOrientation( int partId, DtTaitBryan& orientation );

      virtual void setArtPartLinearRate(int partId, float xRate, float yRate,
         float zRate);

      virtual bool getArtPartLinearRate( int partId, DtVector& rate );

      virtual bool getArtPartTranslationAndRate( int partId, DtVector& translation, DtVector& rate );

      virtual void setArtPartAngularRate(int partId, float yawRate, float pitchRate,
         float rollRate);

      // Get the art part orientation rate from a specified CIGI part id.
      virtual bool getArtPartAngularRate( int partId, DtVector& rate );

      // Get the art part orientation and rate from a specified CIGI part id.
      virtual bool getArtPartOrientationAndRate(  int partId, DtTaitBryan& orientation, DtVector& rate );

      virtual void setArtPartEnable(int partId, bool trueFalse);

      virtual DtSceneObjectAgent* findSceneObjectAgent();

      boost::signal<void (int, DtUniqueID)> signal_alphaChanged;

      enum AnimationStateGroup
      {
         Stop = 0,
         Pause = 1,
         Play = 2,
         Continue = 3,
      };

      virtual void addCollisionSegmentID( unsigned int segmentId );
      virtual void removeCollisionSegmentID( unsigned int segmentId );
      //}@
   protected:
      virtual void startDeadReckoning();

      virtual void endDeadReckoning();

      virtual void startEmbarked();

      virtual void endEmbarked();

      virtual void startGroundClamping();

      virtual void buildGroundClampingUpdater();

      virtual void endGroundClamping();

      virtual bool isGroundClamping() const;

      virtual void getExtrapolatedValuesAndRestart();

      virtual void delayedStartEmbarked();

      virtual void queryExtrapolatedPositionAndOrientation( DtUniqueID drAgentId, bool relative  );

      virtual void returnExtrapolatedPositionAndOrientation( const DtVector& resultPos, 
          const DtTaitBryan& resultOri, bool relative, bool invokeRestart );

      virtual DtDeadReckonUpdater* findDRUpdaterInRenderThread(  DtUniqueID drAgentId ) const;

   protected:
      DtSceneObjectAgent* mySceneObject;
      DtModelAgent* myModel;
      std::string myEntityModelDefName;

      DtDeadReckonUpdaterAgent* myDeadReckonUpdaterAgent;
      DtGroundClampingUpdaterAgent* myGroundClampingUpdaterAgent;
      DtEmbarkationUpdaterAgent* myEmbarkationUpdaterAgent;

      bool myDeadReckoningOn;
      bool myEmbarked;
      DtGroundClampingUpdater::GroundClampingMode myGroundClampingType;

      DtGeodeticCoord myLastPosition;
      DtVector myLastLocalPosition;
 
      DtTaitBryan myLastOrientation;
      DtTaitBryan myLastLocalOrientation;
      DtTaitBryan myLastGeocentricOrientation;

      DtVector myLastRelativePosition;
      DtTaitBryan myLastRelativeOrientation;

      DtVector myLastVelocity;
      bool myLastVelocityWorldCoordinates;

      DtVector myLastAngularVelocity;
      bool myLastAngularVelocityWorldCoordinates;

      DtCigiConnection& myConnection;
      DtAgentManagerInterface& mySceneInterface;

      // This is the CIGI id
      int myEntityId;
      int myEntityType;

      bool myExtendedEntityTypeOn;
      DtEntityType* myExtendedEntityType;

      DtCigiBaseEntity* myParent;

      // This is the parent's CIGI ID
      int myEmbarkedParentID;

      bool myInheritAlpha;
      int  myAlpha;
      bool myVisiblity;

      // Used to ensure uninitialized position vectors are not send to the
      // VR-Link smoother (and we don't attempt to convert orientation from 
      // topo input to database coordinates without a position either)
      bool myPositionSet;
      bool myOrientationSet;

      // Note that while not all entity types can have art parts, there are multiple
      // entity types that derive from baseEntity that do; this avoids duplication in
      // those classes...
      std::map<int, DtTaitBryan> myLastArtPartOrientation;
      std::map<int, DtVector>    myLastArtPartTranslation;
      std::map<int, DtVector>    myArtPartAngularRate;
      std::map<int, DtVector>    myArtPartLinearRate;

      std::list<unsigned int> myCollisionSegmentIdList;

      DtSignalConnectionManager mySignalConnections;
   };


   class DT_DLL_VRVCIGI DtCigiObjectCreator
   {
   public:

      DtCigiObjectCreator()
      {
      }

      virtual ~DtCigiObjectCreator()
      {
      }

      virtual DtCigiObjectCreator* clone() const = 0;

      virtual DtCigiBaseEntity* create(DtCigiConnection& connection,
         DtAgentManagerInterface& sceneInterface, int entityId, 
         int entityType) const = 0;

   };

   template <typename CigiObject>
   class DtCigiObjectCreatorTemplate : public DtCigiObjectCreator
   {
   public:

      DtCigiObjectCreatorTemplate()
      {
      }

      virtual ~DtCigiObjectCreatorTemplate()
      {
      }

      virtual DtCigiObjectCreator* clone() const
      {
         return new DtCigiObjectCreatorTemplate<CigiObject>();
      }

      virtual DtCigiBaseEntity* create( DtCigiConnection& connection,
         DtAgentManagerInterface& sceneInterface, int entityId, 
         int entityType ) const
      {
         return new CigiObject (connection, sceneInterface, entityId, 
            entityType );
      }
   };
}