emitter.h

Go to the documentation of this file.

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

#pragma once

#include "strategies/export.h"
#include "managedInterface/linkStrategy.h"
#include "managedInterface/managedInterface.h"
#include "managedInterface/publisherList.h"

#include <string>
#include <map>

#include <vl/trackJamDesignator.h>
#include <vl/emitterBeamRepository.h>
#include <matrix/vlVector.h>
#include <vlutil/vlTime.h>

class DtMessage;
class DtManagedInterface;
class DtExerciseConn;
class DtReflected;
class DtReflectedEmitterSystem;
class DtReflectedEmitterSystemList;
class DtEmitterSystemPublisher;
class DtEmitterBeamRepository;

#ifdef DtHLA
// Beams are only separate classes in HLA
class DtReflectedEmitterBeam;
class DtReflectedEmitterBeamList;
#endif

class MANAGEDINTERFACE_MODULE_DLL DtEmitterStateStrategy : public DtLinkStrategy
{
public:
   virtual ~DtEmitterStateStrategy();

   std::string name();
   static std::string theName();

   virtual bool init();
   virtual void tick();
   virtual void shutdown();

   static DtLinkStrategy* create(DtManagedInterface* gl);

protected:
   DtEmitterStateStrategy(DtManagedInterface* link);

   void handleCSharpEmitterDiscovered(DtMessage* msg);
   static void vrlEmitterDiscovered(DtReflectedEmitterSystem* emitter, void* usr);
   void handleVrlEmitterDiscovered(DtReflectedEmitterSystem* emitter);

   void handleCSharpEmitterState(DtMessage* msg);
   static void vrlEmitterState(DtReflectedEmitterSystem* emitter, void* usr);
   void handleVrlEmitterState(DtReflectedEmitterSystem* emitter);

   void handleCSharpEmitterRemoved(DtMessage* msg);
   static void vrlEmitterRemoved(DtReflectedEmitterSystem* emitter, void* usr);
   void handleVrlEmitterRemoved(DtReflectedEmitterSystem* emitter);

   DtReflectedEmitterSystemList* myReflectedEmitters;
   DtPublisherList<DtEmitterSystemPublisher>* myEmitterPubs;

   void handleCSharpBeamDiscovered(DtMessage* msg);
   void handleCSharpBeamState(DtMessage* msg);
   void handleCSharpBeamRemoved(DtMessage* msg);

   void sendBeamDiscoveredMessage(const std::string& hostGlobalId, int emitterNumber, DtEmitterBeamRepository* repo);
   void sendBeamStateMessage(const std::string& hostGlobalId, int emitterNumber, DtEmitterBeamRepository* repo, DtTime timeStamp);
   void sendBeamRemovedMessage(const std::string& hostGlobalId, int emitterNumber, DtEmitterBeamRepository* repo);

   DtTrackJamDesignator& makeTrackJamDesignator(DtTrackJamDesignator& designator, const std::string& designatorString);

   // Beams are published by their emitter publishers.

   // Reflected beams are only separate objects in HLA.
#ifdef DtHLA
   static void vrlBeamDiscovered(DtReflectedEmitterBeam* beam, void* usr);
   void handleVrlBeamDiscovered(DtReflectedEmitterBeam* beam);

   static void vrlBeamState(DtReflectedEmitterBeam* beam, void* usr);
   void handleVrlBeamState(DtReflectedEmitterBeam* beam);

   static void vrlBeamRemoved(DtReflectedEmitterBeam* beam, void* usr);
   void handleVrlBeamRemoved(DtReflectedEmitterBeam* beam);

   DtReflectedEmitterBeamList* myReflectedBeams;
#endif

   static std::string theStrategyName;
   const char* myIdTag = "emit";

   DtExerciseConn* myExconn;

   DtMessageDelegate* myEmitterDiscoveredHandler;
   DtMessageDelegate* myEmitterStateHandler;
   DtMessageDelegate* myEmitterRemovedHandler;

   DtMessageDelegate* myBeamDiscoveredHandler;
   DtMessageDelegate* myBeamStateHandler;
   DtMessageDelegate* myBeamRemovedHandler;
};