DtRotorState.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vlutil/vlTime.h>

namespace makVrv
{
   class DtEntityRotorData;

   class DtRotorState
   {
   public:
      DtRotorState(DtEntityRotorData* rotorData);
      virtual ~DtRotorState();
   private:
      DtRotorState() = delete;
      DtRotorState(const DtRotorState& rhs) = delete;
      DtRotorState& operator=(const DtRotorState& rhs) = delete;
   public:
      virtual DtRotorState* handleEvent(int state);

      virtual DtRotorState* update(DtTime timeNow);

      virtual void enter(void);

      virtual void exit(void);
   protected:
      DtEntityRotorData* myRotorData;
   protected:
      static const float theMaxSpeed;
      static const float theTimeToFullSpin;
      static const float theTimeToFullCoolDown;

      static const float theTimeToSwitchToMotionBlur;
   };

   class DtNullRotorState : public DtRotorState
   {
   public:
      DtNullRotorState(DtEntityRotorData* rotorData);
      virtual ~DtNullRotorState();
   private:
      DtNullRotorState() = delete;
      DtNullRotorState(const DtNullRotorState& rhs) = delete;
      DtNullRotorState& operator=(const DtNullRotorState& rhs) = delete;
   public:
      virtual DtRotorState* handleEvent(int state) override;
   protected:

   };

   class FullyOff : public DtRotorState
   {
   public:
      FullyOff(DtEntityRotorData* rotorData);
      virtual ~FullyOff();
   private:
      FullyOff() = delete;
      FullyOff(const FullyOff& rhs) = delete;
      FullyOff& operator=(const FullyOff& rhs) = delete;
   public:
      virtual DtRotorState* handleEvent(int state) override;

      virtual void enter(void) override;
   };

   class FullyOn : public DtRotorState
   {
   public:
      FullyOn(DtEntityRotorData* rotorData);
      virtual ~FullyOn();
   private:
      FullyOn() = delete;
      FullyOn(const FullyOff& rhs) = delete;
      FullyOn& operator=(const FullyOn& rhs) = delete;
   public:
      virtual DtRotorState* handleEvent(int state) override;

      virtual void enter(void) override;
   };

   class SpinningUp : public DtRotorState
   {
   public:
      SpinningUp(DtEntityRotorData* rotorData, float initialVelocity);
      virtual ~SpinningUp();
   public:
      virtual DtRotorState* handleEvent(int state) override;
      virtual DtRotorState* update(DtTime timeNow) override;
   private:
      SpinningUp() = delete;
      SpinningUp(const SpinningUp& rhs) = delete;
      FullyOn& operator=(const SpinningUp& rhs) = delete;
   public:

   protected:
      DtTime myLastUpdateTime;
      DtTime myElapsedTime;
      const float myAcceleration;
      const float myInitialVelocity;
      float myCurrentVelocity;
      bool mySwitchedToMotionBlur;
   };

   class SpinningDown : public DtRotorState
   {
   public:
      SpinningDown(DtEntityRotorData* rotorData, float initial);
      virtual ~SpinningDown();
   private:
      SpinningDown() = delete;
      SpinningDown(const SpinningDown& rhs) = delete;
      SpinningDown& operator=(const SpinningDown& rhs) = delete;
   public:
      virtual DtRotorState* handleEvent(int state) override;
      virtual DtRotorState* update(DtTime timeNow) override;

   protected:
      DtTime myLastUpdateTime;
      DtTime myElapsedTime;
      const float myAcceleration;
      const float myInitialVelocity;
      float myCurrentVelocity;
   };
}