lasingController.h

Go to the documentation of this file.

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


#pragma once

#include "vrfobjcore/singleTaskControllerComponent.h"
#include "vrfmodel/vrfmodelDefines.h"

class DtString;
class DtSimManager;
class DtSimMessage;
class DtLasingControllerDescriptor;
class DtLasingPSR;
class DtBooleanOutputPort;
class DtOutputPortGroup;
class DtBooleanInputPort;
class DtVectorInputPort;
class DtStringInputPort;
class DtOrientationInputPort;
class DtSetTargetRequest;
class DtDesignatorPublisher;
class DtEntityListInputPort;
class DtWeaponComponentInterface;
class DtVrfObjectMessage;

class DT_DLL_vrfmodel DtLasingController : public DtSingleTaskControllerComponent
{
protected:
   DtLasingController();

   DtLasingController(const DtLasingController & 
      orig);

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

public:

   DtLasingController(const DtString& name, 
      DtVrfObject* owner,
      DtSimManager* simManager, 
      DtComponentDescriptor* desc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);

   virtual ~DtLasingController();

   //Initializes the laser controller
   virtual bool init();

   virtual const char* type() const;

   virtual void preFirstTickInit();

   virtual void tick();

   virtual void setDesignatorCode(const int code);
   virtual const int designatorCode() const;

   virtual void clearTask();

   virtual bool createProcessSR();

   virtual void startLasing();
   virtual void stopLasing();

   virtual void laseTarget(const DtVrfObject* targetObject);

   virtual void laseLocation(const DtVector& location);

   virtual bool lasing();

   //static creator
   static DtSimComponent * creator(const DtString& name, 
      DtVrfObject* owner,
      DtSimManager* simManager, 
      DtComponentDescriptor* desc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);

   virtual void registerTaskMsgCallbacks();
   virtual void registerSetLaseAutonomousMsgCallbacks();
   virtual void registerSetLaserCodeRequestMsgCallbacks();
   virtual void registerSetLaserInformationRequestMsgCallbacks();

   //static callbacks to register with the radio for commands to lase a target
   static void laseTargetTaskCallback(DtSimMessage *msg, void * usrData);
   static void laseLocationTaskCallback(DtSimMessage *msg, void * usrData);
   static void setLaseAutonomousRequestCallback(DtSimMessage* msg, void* usrData);
   static void setLaserCodeRequestCallback(DtSimMessage* msg, void* usrData);
   static void setLaserInformationRequestCallback(DtSimMessage* msg, void* usrData);

   //functions to do the work for the static function.
   virtual void processLaseTargetTaskMessage(DtSimMessage *msg);
   virtual void processLaseLocationTaskMessage(DtSimMessage *msg);
   virtual void processSetLaseAutonomousRequestMessage(DtSimMessage* msg);
   virtual void processSetLaserInformationRequestMessage(DtSimMessage* msg);
   virtual void processSetLaserCodeRequestMessage(DtSimMessage* msg);

   static void requestLaserCodeCallback(const DtVrfObjectMessage* msg, void* usr);
   virtual void processRequestLaserCode(const DtVrfObjectMessage* msg);

   virtual void disable();

protected:

   virtual bool createPortGroups();

   virtual bool createPorts();

   virtual bool lineOfSight(const DtVrfObject* target, DtString& reason);

   virtual bool targetPoint(const DtTaitBryan& orientation, DtVector& location);

   virtual DtVector localEyepoint() const;

   //updates the designator state and publishes it on the
   //network
   virtual void tickLaser();

   virtual void setRadio(DtSimRadio * radio);

   virtual bool createPublisher();

   virtual bool createTargetInput();

   virtual double laserPower() const;

   virtual double laserWavelength() const;

   virtual bool laseTargetValid(const DtVrfObject* target, DtString& invalidReason);

   virtual bool laseLocationValid(const DtVector& location, DtString& invalidReason);

   virtual const DtVrfObject* chooseAutonomousLaseTarget();

   virtual int defaultLaserCode() const;

   static void objectAboutToBeRemovedCallback(const DtVrfObject* vrfObject, 
      void* usr);

   virtual void processObjectAboutToBeRemovedCallback(const DtVrfObject* vrfObject);

   class DtLasingControllerInput
   {
   private:

      DtLasingControllerInput();
      DtLasingControllerInput(const DtLasingControllerInput& orig);
      const DtLasingControllerInput& operator=(const DtLasingControllerInput& rhs);
   public:
      DtLasingControllerInput(DtLasingController*);
      virtual ~DtLasingControllerInput();
      virtual bool init();
      virtual const DtVrfObject* getTarget() = 0;
      virtual bool isConnected() = 0;
   protected:
      DtLasingController* myController;
   };

   class DtLasingControllerPortInput : public DtLasingControllerInput
   {
   private:

      DtLasingControllerPortInput();
      DtLasingControllerPortInput(const DtLasingControllerPortInput& orig);
      const DtLasingControllerPortInput& operator=(const DtLasingControllerPortInput& rhs);

   public:
      DtLasingControllerPortInput(DtLasingController*);
      virtual ~DtLasingControllerPortInput();
      virtual bool init();
      virtual const DtVrfObject* getTarget();
      virtual bool isConnected();

   protected:
      DtEntityListInputPort* myTargetListPort;
   };

   class DtLasingControllerWeaponInterfaceInput : public DtLasingControllerInput
   {
   private:

      DtLasingControllerWeaponInterfaceInput();
      DtLasingControllerWeaponInterfaceInput(const DtLasingControllerWeaponInterfaceInput& orig);
      const DtLasingControllerWeaponInterfaceInput& operator=(const DtLasingControllerWeaponInterfaceInput& rhs);
   public:
      DtLasingControllerWeaponInterfaceInput(DtLasingController*);
      ~DtLasingControllerWeaponInterfaceInput();
      virtual bool init();
      virtual const DtVrfObject* getTarget();
      virtual bool isConnected();

   protected:
      DtWeaponComponentInterface* myInterface;
   };

protected:
   const DtVrfObject*                    myCurrentLasedTarget;  

   DtLasingPSR*                    myProcessState;

   const DtLasingControllerDescriptor*   myComponentDescriptor;
   DtDesignatorPublisher*          myDesPublisher;

   bool myConnectedToLauncher; 

   DtLasingControllerInput* myLasingInput;

   bool myInvalidTargetMsgPrinted;

   DtBooleanInputPort* myLaserOnInputPort;

   DtVectorInputPort* myTargetLocationInputPort;

   DtStringInputPort* myTargetObjectInputPort;

   DtInputPortGroup* myLaserOffsetInputPortGroup;

   DtOrientationInputPort* myOrientationInputPort;

   DtVectorInputPort* myPositionInputPort;
};

int generateLaserCodeFromName(const DtString& objectName);