DtMotionModel.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2015 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 modelAdded(DtModel*) = 0;

      virtual void modelRemoved(DtModel*) = 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;
   };

   template <typename DeadReckoner>
   class DT_DLL_VRVCORE DtVRLDeadReckonerMotionModel : public DtMotionModel,
      protected DeadReckoner
   {
   public:
      DtVRLDeadReckonerMotionModel()
         : DtMotionModel()
         , DeadReckoner()
      {
      }
      DtVRLDeadReckonerMotionModel(const DtVRLDeadReckonerMotionModel& orig, double time)
         : DtMotionModel(orig)
         , DeadReckoner(orig)
      {
         setAlgorithm(orig.algorithm());
         setSmoothingEnabled(orig.mySmoothEnable);
         setSmoothPeriod(orig.smoothPeriod());
      }

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

      virtual void updateMotion(double dtTime)
      {

      }

      virtual void modelAdded(DtModel*)
      {
         //Intentionally do nothing
      }

      virtual void modelRemoved(DtModel*)
      {
         //Intentionally do nothing
      }

      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();
      }

   };

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

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

}