DtMotionModel.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <matrix/vlVector.h>
#include <matrix/vlTaitBryan.h>
#include <vlutil/vlTime.h>
#include <vlpi/disEnums.h>

namespace makVrv
{
   class DtSceneObject;
   class DtModel;
   class DtDe;

   class DT_DLL_VRVCORE DtMotionModel
   {
   public:

      DtMotionModel();

      virtual ~DtMotionModel();

      virtual void updateMotion(double dtTime) = 0;

      virtual void setAll(
         const DtVector& loc,
         const DtVector32& vel,
         const DtTaitBryan& ori,
         const DtVector32& acc,
         const DtVector32& rotVel,
         DtTime t) = 0;

      virtual const DtTime& velocityUpdateTime() const = 0;
      virtual const DtTime& locationUpdateTime() const = 0;

      virtual void setLocation(const DtVector& loc, DtTime curTime) = 0;

      virtual const DtVector& approxLocation(DtTime curTime) const = 0;

      virtual void setVelocity(const DtVector32& vel, DtTime curTime) = 0;

      virtual const DtVector32& approxVelocity(DtTime curTime) const = 0;

      virtual const DtVector32& approxUnsmoothedVelocity(DtTime curTime) const = 0;

      virtual void setOrientation(const DtTaitBryan& ori, DtTime curTime) = 0;

      virtual const DtTaitBryan& approxEuler(DtTime curTime) const = 0;

      virtual void setAcceleration(const DtVector32& acc, DtTime curTime) = 0;
      virtual const DtVector32& acceleration(DtTime curTime) const = 0;

      virtual void setRotationalVelocity(const DtVector32& vel, DtTime curTime) = 0;
      virtual const DtVector32& rotationalVelocity(DtTime curTime) const = 0;

      virtual void setSmoothPeriod(float period) = 0;
      virtual void setSmoothingEnabled(bool enabled) = 0;

      virtual void setAlgorithm(DtDeadReckonTypes alg) = 0;
      virtual DtDeadReckonTypes algorithm() const = 0;

      virtual DtMotionModel* clone(double time) = 0;
       
      virtual void reset() = 0;


      virtual void setFrozen( bool frozen ) = 0;
      virtual bool isFrozen() const = 0;



      virtual void setDeadReckoningEnabled( bool enabled ) = 0;
      virtual bool isDeadReckoningEnabled() const = 0;

   };

   template <typename DeadReckoner>
   class DT_DLL_VRVCORE DtVRLDeadReckonerMotionModel : public DtMotionModel,
      protected DeadReckoner
   {
   public:

      DtVRLDeadReckonerMotionModel()
         : DtMotionModel()
         , DeadReckoner()
         , myDeadReckoningEnabledFlag( true )
      {
      }

      DtVRLDeadReckonerMotionModel(const DtVRLDeadReckonerMotionModel& orig, double time)
         : DtMotionModel( orig )
         , DeadReckoner( orig )
         , myDeadReckoningEnabledFlag( orig.myDeadReckoningEnabledFlag )
      {
         setAlgorithm(orig.algorithm());
         setSmoothingEnabled(orig.mySmoothEnable);
         setSmoothPeriod(orig.smoothPeriod());
      }

      DtMotionModel* clone( double time )
      {
         return new DtVRLDeadReckonerMotionModel( *this, time );
      }

      virtual void updateMotion(double dtTime)
      {
      }

      virtual const DtTime& velocityUpdateTime() const
      {
         return DeadReckoner::velocityUpdateTime();
      }

      virtual const DtTime& locationUpdateTime() const
      {
         return DeadReckoner::locationUpdateTime();
      }

      virtual void setAll(
         const DtVector& loc,
         const DtVector32& vel,
         const DtTaitBryan& ori,
         const DtVector32& acc,
         const DtVector32& rotVel,
         DtTime curTime)
      {
         DeadReckoner::setAll(loc, vel, ori, acc, rotVel, curTime);
      }

      virtual void setLocation(const DtVector& loc, DtTime curTime)
      {
         DeadReckoner::setLocation(loc,curTime);
      }

      virtual const DtVector& approxLocation(DtTime curTime) const
      {
         return DeadReckoner::approxLocation(curTime);
      }

      virtual void setVelocity(const DtVector32& vel, DtTime curTime)
      {
         return DeadReckoner::setVelocity(vel,curTime);
      }

      virtual const DtVector32& approxVelocity(DtTime curTime) const
      {
         return DeadReckoner::approxVelocity(curTime);
      }

      virtual const DtVector32& approxUnsmoothedVelocity(DtTime curTime) const
      {
         return DeadReckoner::approxUnsmoothedVelocity(curTime);
      }

      virtual void setOrientation(const DtTaitBryan& ori, DtTime curTime)
      {
         DeadReckoner::setOrientation(ori,curTime);
      }

      virtual void setSmoothPeriod(float period)
      {
         DeadReckoner::setSmoothPeriod(period);
      }

      virtual void setSmoothingEnabled(bool enabled)
      {
         DeadReckoner::setSmoothEnable(enabled);
      }

      virtual const DtTaitBryan& approxEuler(DtTime curTime) const
      {
         return DeadReckoner::approxEuler(curTime);
      }

      virtual void setAcceleration(const DtVector32& acc, DtTime curTime)
      {
         DeadReckoner::setAcceleration(acc,curTime);
      }

      virtual const DtVector32& acceleration(DtTime curTime) const
      {
         return DeadReckoner::acceleration(curTime);
      }

      virtual void setRotationalVelocity(const DtVector32& vel, DtTime curTime)
      {
         DeadReckoner::setRotationalVelocity(vel,curTime);
      }

      virtual const DtVector32& rotationalVelocity(DtTime curTime) const
      {
         return DeadReckoner::rotationalVelocity(curTime);
      }

      virtual void setAlgorithm(DtDeadReckonTypes alg)
      {
         DeadReckoner::setAlgorithm(alg);
      }

      virtual DtDeadReckonTypes algorithm() const
      {
         return DeadReckoner::algorithm();
      }

      virtual void reset()
      {
         DeadReckoner::reset();
      }

      virtual void setFrozen( bool frozen )
      {
         DeadReckoner::setFrozen( frozen );
      }

      virtual bool isFrozen() const
      {
         return DeadReckoner::isFrozen();
      }

      virtual void setDeadReckoningEnabled( bool enabled )
      {
         myDeadReckoningEnabledFlag = enabled;
      }

      virtual bool isDeadReckoningEnabled() const
      {
         return myDeadReckoningEnabledFlag;
      }

   protected:

      bool myDeadReckoningEnabledFlag;

   };


   class DT_DLL_VRVCORE DtMotionModelCreator
   {
   public:
      virtual ~DtMotionModelCreator();
      virtual DtMotionModel* create( DtDe& de ) = 0;
   };   

   class DT_DLL_VRVCORE DtDefaultMotionModelCreator : public DtMotionModelCreator
   {
   public:
      DtMotionModel* create( DtDe& de );
   };

}