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 override
      {
         return DeadReckoner::velocityUpdateTime();
      }

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

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

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

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

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

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

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

      virtual void setOrientation( const DtTaitBryan& ori, DtTime curTime ) override
      {
         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 override
      {
         return DeadReckoner::approxEuler( curTime );
      }

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

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

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

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

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

      virtual DtDeadReckonTypes algorithm() const override
      {
         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 );
   };

}