aggregatedMovementActuator.h

Go to the documentation of this file.

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


#pragma once

#include "vrfobjcore/actuatorComponent.h"
#include "vrfobjparam/aggregatedMovementDescriptor.h"
#include "vrfobjcore/aggregateLocalObjectFacade.h"
#include "vrfmodel/vrfmodelDefines.h"

#include "features/featureGeometry.h"
#include "features/featureSet.h"
#include "features/proj.h"

#include <boost/ptr_container/ptr_vector.hpp>

class DtInputPortGroup;
class DtAnalogInputPort;
class DtVrfMovingObjectStateRepository;
class DtVrfAggregateStateRepository;
class DtActuatorComponentDescriptor;
class DtTerrainInterface;
class DtSetDataManager;
class DtBooleanInputPort;
class DtVectorInputPort;
class DtAggregatedMovementActuatorPSR;

#define ALTITUDE_CHANGE_INCREMENT 304.8  

namespace MAKVRinTerra
{
   class DtFeatureGeometry;
}

class DT_DLL_vrfmodel DtAggregatedMovementActuator : public DtActuatorComponent
{

public:

   DtAggregatedMovementActuator(const DtString& name, DtLocalObject* object, 
      DtSimulationServices* simManager, DtComponentDescriptor* compDescriptor, 
      DtReaderWriterRegistry* parentRegistry = 0);

   virtual ~DtAggregatedMovementActuator() override;

   virtual bool init() override;

   virtual bool createPSR();

   virtual const char* type() const override;

   virtual void tick() override;

   virtual void setOrderedAltitude(double altitude, bool aboveGroundLevel = false);

public:

   static DtSimComponent* creator(const DtString& name, DtLocalObject* object,
      DtSimulationServices* simManager, DtComponentDescriptor* compDescriptor,
      DtReaderWriterRegistry* parentRegistry);

   static bool setHaltMovementForObstacles(void* controller, DtReaderWriter* value);

   static bool setObstacleQueryName(void* controller, DtReaderWriter* value);

   static DtReaderWriter* isHalted(void* controller);

   static DtReaderWriter* blockingObstacle(void* controller);

   static DtReaderWriter* timeHalted(void* controller);

protected:
   virtual DtVector calculateProjectedLocation(
      const DtVector& oldLocalPosition, const DtVector& newBodyVelocity,
      double newHeading);

   virtual std::string calculateOrientationAndPosition(
      const DtVector& newLocalProjectedLocation, double newHeading,
      DtDcm& newLocalOrientation, DtVector& newLocalPosition);

   virtual void calculateFuelUsage(
      double distanceTraveled,
      double velocity,
      double altitude);

   virtual std::string adjustToTerrain(
      double heading, const DtVector& location, DtVector& newNormal);

   virtual void updateRepository(const DtVector & position,
      const DtVector & velocity, const DtVector & acceleration,
      const DtTaitBryan & localOrientation, const DtVector& rotationalVelocity);

   virtual bool isObstructedByObstacles(const MAKVRinTerra::DtFeatureGeometry& location);

   static void setObstacleToIgnore(DtSimMessage* msg, void* usr);

   virtual void processObstacleToIgnore(DtSimMessage* msg);

protected:
   virtual bool createPorts() override;

   virtual bool createPortGroups() override;

   class ErrorStream;
   virtual bool haveSupplies(ErrorStream &errorStream) const;

   virtual double scriptModifier() const;

   virtual double scriptAdjustment() const;

   virtual double maximumSpeedModifierFromFeatures(const MAKVRinTerra::DtFeatureGeometry&, 
      double& slope) const;

   virtual double retrogradeMovementModifier() const;

   DtAggregatedMovementActuator(const DtAggregatedMovementActuator & orig);

   const DtAggregatedMovementActuator & operator=(const DtAggregatedMovementActuator & orig);

   virtual bool checkPassedDestination(const DtVector& currentPosition, DtVector& newLocalProjectedPosition);

   virtual bool setHaltMovementForObstacles(DtReaderWriter* value);

   virtual bool setObstacleQueryName(DtReaderWriter* value);

   virtual void setAircraftAirborne(const DtVector& location);

   virtual DtReaderWriter* isHalted();

   virtual DtReaderWriter* blockingObstacle();

   virtual DtReaderWriter* timeHalted();

protected:

   DtVector                         myPrep_oldLocalPosition;
   DtVector                         myPrep_oldLocalVelocity;
   DtTaitBryan                      myPrep_oldLocalOrientationTb;
   DtVector                         myPrep_oldBodyVelocity;
   DtVector                         myPrep_newLocalPosition;
   DtVector                         myPrep_newRelativeVelocity;
   DtVector                         myPrep_newBodyRotationalVelocity;
   DtTaitBryan                      myPrep_newLocalOrientationTb;
   boost::optional<double>          myPrep_desiredAltitude;


   DtAnalogInputPort* myMovementDirectionInputPort;

   DtAnalogInputPort* mySpeedInputPort;

   DtInputPortGroup* myMovementControlPortGroupInputPortGroup;

   DtAnalogInputPort* myAltitudeInputPort;

   DtVectorInputPort* myDestinationInputPort;

   DtVrfMovingObjectStateRepository* myMovingObjectStateRep;

   const DtActuatorComponentDescriptor*  myBaseActuatorDescriptor;
   const DtAggregatedMovementDescriptor* myActuatorDescriptor;

   DtSetDataManager* mySetDataManager;

   typedef MAKVRinTerra::DtFeatureSet FeatureSet;

   typedef DtAggregatedMovementDescriptor::MobilityEntry MobilityEntry;

   class MobilityArea : boost::noncopyable
   {
   public:
      typedef boost::ptr_vector<MobilityArea> Vector;

      MobilityArea(const MobilityEntry&, DtTerrainInterface*);

      const MobilityEntry& entry() const;
      const FeatureSet& featureSet() const;

   private:
      const MobilityEntry& myEntry;
      std::unique_ptr<FeatureSet> myFeatureSet;
   };

   MobilityArea::Vector myMobilityAreas;


   class ErrorStream
   {
   public:
      ErrorStream() : myEmptyFlag(true) { }

      template <typename T>
      ErrorStream& operator<< (const T& value)
      {
         myEmptyFlag = false;
         myStream << value;
         return *this;
      }
      std::string str() const
      {
         return myStream.str();
      }
      bool empty() const
      {
         return myEmptyFlag;
      }

   private:
      std::stringstream myStream;
      bool myEmptyFlag;
   };

   bool myErrorCondition;

   std::unique_ptr<FeatureSet> myEngineeringObjFeatureSet;

   std::unique_ptr<FeatureSet> myEngineeringObjObstacleFeatureSet;

   DtBooleanInputPort* myRetrogradeInputPort;

   DtAggregatedMovementActuatorPSR* myProcessState;

   DtAggregateLocalObjectFacade myAggregateLocalObjectFacade;
};