WsfMover.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
// ****************************************************************************
// Updated by Infoscitex, a DCS Company
// ****************************************************************************
 
#ifndef WSFMOVER_HPP
#define WSFMOVER_HPP
 
#include "wsf_export.h"
 
#include "UtVec3.hpp"
#include "WsfAttributeContainer.hpp"
class WsfDraw;
class WsfGeoPoint;
class WsfModeList;
class WsfMoverMode;
#include "WsfPath.hpp"
#include "WsfPlatformPart.hpp"
class WsfRoute;
#include "WsfVariable.hpp"

class WSF_EXPORT WsfMover : public WsfPlatformPart
{
public:
   static const char* cTYPE_KIND;
 
   WsfMover() = delete;
   WsfMover(const WsfScenario& aScenario);
   WsfMover(const WsfMover& aSrc);
   WsfMover& operator=(const WsfMover&) = delete;
   ~WsfMover() override;


   WsfComponent* CloneComponent() const override { return Clone(); }
   int           GetComponentInitializationOrder() const override { return cWSF_INITIALIZE_ORDER_MOVER; }
   const int*    GetComponentRoles() const override;
   void*         QueryInterface(int aRole) override;



   WsfMover* Clone() const override = 0;
 
   const char* GetScriptClassName() const override;
 
   virtual void SwapMoverInitiated(double aSimTime, WsfMover* aOldMoverPtr);
   bool         Initialize(double aSimTime) override;
   using WsfPlatformPart::Initialize2;
   bool ProcessInput(UtInput& aInput) override;
   void Update(double aSimTime) override;


   void TurnOff(double aSimTime) override;
   void TurnOn(double aSimTime) override;
   void SetNonOperational(double aSimTime) override;
   void SetOperational(double aSimTime) override;
   void PartBroken(double aSimTime) override;
   void Restore(double aSimTime) override;
 
   virtual WsfSpatialDomain GetSpatialDomain() const;
 
   virtual bool IsStopped() const;
   virtual bool IsPaused() const;
   virtual bool IsExtrapolating() const;
 
   virtual void SetHeading(double aHeading);
   virtual void SetPitch(double aPitch);
   virtual void SetRoll(double aRoll);
 
   virtual void SetOrientationNED(double aHeading, double aPitch, double aRoll);

   //  * Used in SetRoute or to move platform
   virtual void ResetPosition(double aSimTime) {}



   double GetLastUpdateTime() const { return mLastUpdateTime; }

   double GetUpdateInterval() const override { return mUpdateInterval; }

   double GetUpdateTimeTolerance() const { return mUpdateTimeTolerance; }

   void SetUpdateInterval(double aUpdateInterval) override { mUpdateInterval = aUpdateInterval; }

   void SetLastUpdateTime(double aLastUpdateTime) { mLastUpdateTime = aLastUpdateTime; }
 
   virtual bool UpdateAllowed() const;
 
   bool UpdateWhenBroken() const { return mUpdateWhenBroken; }
   void SetUpdateWhenBroken() { mUpdateWhenBroken = true; }
   void SetNoUpdateWhenBroken() { mUpdateWhenBroken = false; }


   virtual const WsfRoute* GetRoute() const;
 
   virtual const WsfRoute* GetDefaultRoute() const;
 
   virtual int RoutePointIndex() const { return 0; }
 
   virtual bool GoToAltitude(double aSimTime, double aAltitude, double aClimbDiveRate, bool aKeepRoute);
 
   virtual bool ReturnToRoute(double aSimTime);
 
   virtual bool GoToClosestPoint(double aSimTime);
 
   virtual bool GoToLabel(double aSimTime, WsfStringId aLabelId);
 
   virtual bool GoToLocation(double aSimTime, double aLatitude, double aLongitude, double aAltitude);
 
   virtual bool GoToSpeed(double aSimTime, double aSpeed, double aLinearAccel, bool aKeepRoute);
 
   virtual bool TurnToHeading(double aSimTime, double aHeading, double aRadialAccel, WsfPath::TurnDirection aTurnDirection);
 
   virtual bool TurnToRelativeHeading(double                 aSimTime,
                                      double                 aHeadingChange,
                                      double                 aRadialAccel,
                                      WsfPath::TurnDirection aTurnDirection);
 
   virtual bool SetRoute(double aSimTime, const WsfRoute& aRoute);
 
   virtual bool UpdateRoute(double aSimTime, const WsfRoute& aRoute);
 
   virtual bool UpdateDefaultRoute();
 
   virtual bool GoToWaypoint(double aSimTime, unsigned int aDestination);
 
   virtual bool FindAndSetPath(double aSimTime, WsfGeoPoint* aStartPtr, WsfGeoPoint* aEndPtr);
 
   virtual bool FlyRates(const UtVec3d& aAngularRates, // radians/sec
                         const UtVec3d& aLongitudinalAccel)
   {
      return false;
   } // meters/sec^2
 
   virtual bool FlyHeadingSpeedAltitude(double aHeading,  // deg
                                        double aSpeed,    // meters/sec
                                        double aAltitude, // meters
                                        double aMaxGees,  // Gs
                                        double aMaxClimb)
   {
      return false;
   } // meters/sec
 
   virtual bool TurnInPlaneWithSpeed(const UtVec3d& aPlane, // world coordinates (not body coordinates)
                                     double         aGees,  // Gs
                                     double         aSpeed)
   {
      return false;
   } // meters/sec
 
   virtual bool TurnInPlaneWithThrottle(const UtVec3d& aPlane, // world coordinates (not body coordinates)
                                        double         aGees,  // Gs
                                        double         aThrottle)
   {
      return false;
   } //[0-3]
 
   virtual bool FlyVectorWithSpeed(const UtVec3d& aVelocityVector, // world coordinates (not body coordinates)
                                                                   // (magnitude does not matter, just direction)
                                   double aMaxGees,                // Gs
                                   double aSpeed)
   {
      return false;
   } // meters/sec
 
   virtual bool FlyVectorWithThrottle(const UtVec3d& aVelocityVector, // world coordinates (not body coordinates)
                                                                      // (magnitude does not matter, just direction)
                                      double aMaxGees,                // Gs
                                      double aThrottle)
   {
      return false;
   } //[0-3]

 
   virtual bool ExecuteTriggers(double aSimTime, unsigned int aPointIndex);
 
   virtual bool GetFutureLocationWCS(double aSimTime, double aLocationWCS[3]);

   WsfStringId  GetModeId() const { return mModeId; }
   virtual void SetMode(WsfStringId aModeName);

   bool ThreadSafe() const { return mThreadSafe; }
   void SetThreadSafe() { mThreadSafe = true; }
   void SetNotThreadSafe() { mThreadSafe = false; }



   virtual void InitializeProperties(){};

   virtual bool PropertyExists(const std::string& aPropertyName);

   virtual void RegisterProperty(const std::string& aPropertyName, const int& aProperty);
   virtual void RegisterProperty(const std::string& aPropertyName, const double& aProperty);
   virtual void RegisterProperty(const std::string& aPropertyName, const std::string& aProperty);

   virtual bool GetPropertyInt(const std::string& aPropertyName, int& aProperty);
   virtual bool GetPropertyDouble(const std::string& aPropertyName, double& aProperty);
   virtual bool GetPropertyString(const std::string& aPropertyName, std::string& aProperty);

   virtual double GetThrottlePosition() { return 1.0; }



   virtual double TurnRadius(double atSpeed) { return 0.0; } // TODO //returns meters
 
   WsfModeList* GetModeList() const { return mModeListPtr; }

   virtual void TriggerExtrapolation();

   class WSF_EXPORT KinematicModel
   {
   public:
      KinematicModel()                           = delete;
      KinematicModel(const KinematicModel& aSrc) = default;
      virtual ~KinematicModel();
 
      double GetApogeeTime() const { return mApogeeTime; }
      double GetTimeAtLocation() const { return mTimeAtLocation; }
      double GetStartTime() const { return mStartTime; }

      virtual bool GetLocationXYZ(double aTime, double aLocXYZ[3]) const = 0;

      virtual bool GetVelocityXYZ(double aTime, double aVelXYZ[3]) const = 0;
 
      static void GetRangeAndAltitude(const double aOriginLocXYZ[3],
                                      const double aModelLocXYZ[3],
                                      double&      aRange,
                                      double&      aAltitude);
 
   protected:
      KinematicModel(double aSimTime, WsfStringId aModelTypeId);
 
      double      mStartTime;
      double      mApogeeTime;
      double      mTimeAtLocation;
      WsfStringId mModelTypeId;
   };

   virtual KinematicModel* CreateKinematicModel(double       aSimTime,
                                                WsfStringId  aPlatformTypeId,
                                                const double aLocationWCS[3],
                                                const double aVelocityWCS[3],
                                                WsfMover*    aMoverPtr,
                                                WsfDraw*     aDrawPtr) const
   {
      return nullptr;
   }
 
protected:
   void SetModeList(WsfModeList* aModeListPtr);

   void SetUpdateTimeTolerance(double aDt) { mUpdateTimeTolerance = aDt; }
 
   double mLastUpdateTime; 

   WsfVariable<double> mUpdateTimeTolerance;

   bool mThreadSafe;

   std::vector<WsfMoverMode*> mMoverModeList;
 
   WsfStringId mModeId;
 
private:
   WsfModeList* mModeListPtr;
 
   bool                   HasProperties() const { return mPropertiesPtr != nullptr; }
   WsfAttributeContainer& GetProperties() const;

   WsfVariable<double> mUpdateInterval;

   mutable WsfAttributeContainer* mPropertiesPtr;

   bool mUpdateWhenBroken;
};
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(WsfMover, cWSF_COMPONENT_MOVER)
 
#endif