DtAttachableUpdater.h

Go to the documentation of this file.

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


#pragma once

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

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

#include <list>

namespace makVrv
{

   class DtDe;
   class DtSceneObject;
   class DtSceneObjectUpdater;

   class DT_DLL_VRVCORE DtAttachableUpdater : public DtTickable

   {
   public:

      enum AttachedPointType
      {
         AttachedPointTypeVertex,
         AttachedPointTypeObject,
         AttachedPointTypeProportional,
         AttachedPointTypeDeprecatedObject,
         AttachedPointTypeInvalidObject
      };

      enum AttachedPointMode
      {
         AttachedPointModePositionAndOrientation,
         AttachedPointModePositionOnly,
         AttachedPointModeOrientationOnly
      };

      class AttachedPoint
      {
      public:

         AttachedPoint( AttachedPointType type, int targetVertexIndex,
               const DtVector& positionOffset )
            : myAttachedPointType( type )
            , myTargetVertexIndex( targetVertexIndex )
            , myPositionOffset( positionOffset )
          , myAttachedPointMode(AttachedPointModePositionAndOrientation)
         {
         }

         virtual ~AttachedPoint() {}

         AttachedPointType type() const
         {
            return myAttachedPointType;
         }

         int targetVertexIndex()
         {
            return myTargetVertexIndex;
         }

         void setPositionOffset(const DtVector& o)
         {
            myPositionOffset = o;
         }

         const DtVector& positionOffset() const
         {
            return myPositionOffset;
         }

         void setAttachedPointMode( AttachedPointMode mode )
         {
            myAttachedPointMode = mode;
         }

         AttachedPointMode attachedPointMode() const
         {
            return myAttachedPointMode;
         }

        protected:

         AttachedPointType myAttachedPointType;
         int myTargetVertexIndex;
         DtVector myPositionOffset;
         AttachedPointMode myAttachedPointMode;

      };

      class ObjectAttachedPoint : public AttachedPoint
      {
      public:

         ObjectAttachedPoint( DtSceneObject* sceneObject, DtSceneObjectUpdater* updater,
               int targetVertexIndex, const DtVector& positionOffset )
            : AttachedPoint( AttachedPointTypeObject, targetVertexIndex, positionOffset )
            , mySceneObject( sceneObject )
            , myUpdater( updater )
            , mySceneObjectId( 0 )
         {
         }

         virtual ~ObjectAttachedPoint() {}

         inline void setSceneObject( DtSceneObject* sceneObject )
         {
            mySceneObject = sceneObject;

            if (sceneObject)
            {
               mySceneObjectId = sceneObject->uniqueId();
            }
            else
            {
               mySceneObjectId = 0;
            }
         }

         inline DtUniqueID sceneObjectId() const
         {
            return mySceneObjectId;
         }

         inline DtSceneObject* sceneObject() const
         {
            return mySceneObject;
         }

         inline void setUpdater( DtSceneObjectUpdater* updater )
         {
            myUpdater = updater;
         }

         inline DtSceneObjectUpdater* updater() const 
         {
            return myUpdater;
         }

         //  When the class is destructed, the scene object may or may not 
         // exist.  Using a separate connection variable makes it possible to
         // 'disconnect' even if the scene object has been deleted.
         boost::signalslib::connection mySceneObjectConnection;
         boost::signalslib::connection mySceneObjectUpdaterConnection;

      protected:

         DtSceneObject* mySceneObject;
         DtSceneObjectUpdater* myUpdater;
         DtUniqueID mySceneObjectId;
      };

      class VertexAttachedPoint : public AttachedPoint
      {
      public:

         VertexAttachedPoint( const DtVector& position, int targetVertexIndex,
               const DtVector& positionOffset )
            : AttachedPoint( AttachedPointTypeVertex, targetVertexIndex, positionOffset )
            , myVertex( position )
         {
         }
         virtual ~VertexAttachedPoint() {}

         DtVector vertex() const
         {
            return myVertex;
         }

      protected:

         DtVector myVertex;
      };

      class LinearAttachedPoint : public ObjectAttachedPoint
      {
      public:

         LinearAttachedPoint( DtSceneObject* sceneObject, DtSceneObjectUpdater* updater,
               int vtx1, int vtx2, double proportion, int targetVertexIndex,
               const DtVector& positionOffset )
            : ObjectAttachedPoint( sceneObject, updater, targetVertexIndex, positionOffset )
            , myFirstVtx( vtx1 )
            , mySecondVtx( vtx2 )
            , myProportion( proportion )
         {
            myAttachedPointType = AttachedPointTypeProportional;
         }

         inline int firstVtx()
         {
            return myFirstVtx;
         }

         inline int secondVtx()
         {
            return mySecondVtx;
         }

         inline double proportion()
         {
            return myProportion;
         }

      protected:

         int myFirstVtx;
         int mySecondVtx;
         double myProportion;

      };

   public:

      DtAttachableUpdater( DtDe& de, DtUniqueID id );

      virtual ~DtAttachableUpdater();

      virtual bool needsUpdate( DtTime tNow );

      virtual void addAttachedPoint( const DtVector& position, int targetVertexIndex );

      virtual void addAttachedPoint( DtUniqueID uniqueID, int targetVertexIndex );

      virtual void addAttachedPoint( DtUniqueID uniqueID, int vtx1, int vtx2,
         double proportion, int targetVertexIndex );

      virtual const AttachedPoint& attachedPoint( int targetVertexIndex ) const;

      virtual void setPositionOffset( const DtVector& offset );

      virtual void setWorldPositionOffset( const DtVector& offset );

      virtual void setPositionOffset( const DtVector& offset, int vtx );

      virtual void setOrientationOffset(const DtTaitBryan& offset);

      virtual void setWorldOrientationOffset(const DtTaitBryan& offset);

      virtual void setAttachedPointMode( unsigned int mode, int vtx );

      virtual void update( DtTime tNow );

      virtual void setSceneObject( DtSceneObject* sceneObject );

      virtual void doAttachment( DtTime tNow );

      inline DtTime lastUpdateTime() const
      {
         return myLastUpdateTime;
      }

   protected:

      virtual void slot_sceneObjectToBeDeleted( const DtUniqueID& id );
      virtual void slot_attachedSceneObjectToBeDeleted( const DtUniqueID& );
      virtual void slot_attachedUpdaterToBeDeleted( const DtUniqueID& id );

      // get values of attached point at simTime
      virtual bool pointLocationAndOrientation( AttachedPoint* point, 
         double simTime, DtVector& location, DtTaitBryan& orientation );

      virtual void removeAttachedPoint(int vtx, DtVector* positionOffset = 0);

   protected:
      DtDe& myDe;

      DtUniqueID myUniqueId;

      DtSceneObject* mySceneObject;

      //  When the class is destructed, the scene object may or may not 
      // exist.  Using a separate connection variable makes it possible to
      // 'disconnect' even if the scene object has been deleted.
      boost::signalslib::connection mySceneObjectConnection;
      boost::signalslib::connection mySceneObjectUpdaterConnection;

      DtTime myLastUpdateTime;

      typedef std::vector<AttachedPoint*> AttachedPointsVector;
      AttachedPointsVector myAttachedPoints;

      DtVector myPositionOffset;
      DtTaitBryan myOrientationOffset;

      DtVector myWorldPositionOffset;
      DtTaitBryan myWorldOrientationOffset;

      DtUniqueID mySceneObjectId;
   };
}