vrfApp.h

Go to the documentation of this file.

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

#include <vlutil/vlString.h>
#include <vlutil/vlList.h>
#include <vlutil/vlUtil.h>
#include <vl/hostStructs.h>
#include <vlutil/vlFilename.h>
#include <vl/rprFomMapper.h>
#include <vlutil/vlTime.h>
#include <vl/exerciseConn.h>

class DtCgf;
class DtCgfDispatcher;
class DtExerciseConn;
class DtFomMapper;
class DtBatchManager;
class DtVrfCreator;
class DtVrfSimOptions;
#ifdef WIN32
class DtFilePrinter;
class DtWindowsConsolePrinter;
#endif
class DtBackendConsoleNetworkPrinter;

// class DtVrfApp:
//
// Instances of DtVrfApp are the main class for the VR-Forces simulation
// back-end application.

class DtVrfApp
{
public:
   
   // constructor
   DtVrfApp(int argc, char** argv);
   
   // destructor
   virtual ~DtVrfApp();
   
   // Initialization.  Must be called before any other member functions
   // are called.
   virtual bool init(DtVrfCreator* creator = 0);
   
   // Main execution loop.  Calls our DtCgf's tick(). Calls DtSleep() for a 
   // given time interval (the main loop sleep interval).  Polls the keyboard
   // for input.  If a 'q' key press is received, exits the application.
   virtual void mainLoop();
   
   // Accessor for the DtCgf
   virtual DtCgf* cgf();

   // Accessor for the DtExerciseConn
   virtual DtExerciseConn* exerciseConn();

#ifdef WIN32
   virtual void setConsoleWindow(HWND consoleWindow);
#endif

   static void setUserRequestedShutdown(bool);
   static bool userRequestedShutdown();

   static DtVrfApp* app();

protected:
   
   // Process mtl file.  Also reads off mtl file (optionally) added to
   // command line by -d command
   virtual bool processMtlFile(int argc, char** argv);

   // Creates our cgf (called from init())
   virtual DtCgf* createCgf(const DtSimulationAddress& addr);
   
   // Creates our simOptions (called from init())
   virtual DtVrfSimOptions* createSimOptions();

   // This routine will read in the simulation options from the vrfSim.mtl
   // file by default of the supplied filename
   virtual bool readSimOptions(const DtFilename& mtlFile);

   // This routine will process the options read from the mtl file and set
   // them in the appropriate places in the cgf.  This method is called
   // after the cgf has been initialized
   virtual void processCgfOptions();

   // This routine will process app level options (parameter database, port, 
   // etc).  This is called before processCgfOptions and before
   // processCommandLine such that the command line options will take
   // precedence over the .mtl options
   virtual void processAppOptions();

   // Gets keyboard input and sends it to console command manager.
   // Returns false if  mainloop should exit.
   // Called during mainloop.
   virtual bool processKeyboardInput();

   // Prints out some general tracking information to console about this build (info level)
   virtual void printGeneralInfoToConsole();

   // Ticks subcomponents. Returns false is mainloop should exit.
   // Called during mainloop.
   virtual bool tick();

   virtual void initializeCgfForScenarioOrTerrain();

   virtual void initializeCgfRunState();

   virtual void exec();

#ifdef WIN32
   bool frontEndStillActive(HANDLE processHandle);
#else
   bool frontEndStillActive();
#endif

   virtual bool createExerciseConnection();

protected:
   virtual void initializePluginsForCommandLineArguments(DtVrfCreator* creator);

private:
   // copy constructor - not implemented
   DtVrfApp(const DtVrfApp& orig);
   
   // assignment operator - not implemented
   DtVrfApp& operator=(const DtVrfApp& orig);
   
protected:

   // Our DIS/RPR (site id, application id) simulation address that
   // uniquely identifies our application in an exercise.
   DtSimulationAddress mySimAddress;

   // VR-Link exercise connection.  Provides means by which all network
   // interactions (PDUs/HLA objects and interactions) are sent/recieved.
   DtExerciseConn* myExerciseConn;

   // Command line arguments are cached in our constructor so we can process 
   // them later in init().
   int myArgc;
   char** myArgv;

   // Driver for our CGF object that responds to network messages
   DtCgfDispatcher* myDispatcher;

   // Driver for CGF Object that handles execution of scenario batches.
   DtBatchManager *myBatchManager;

   // Options that are read in from the vrfSim.mtl file
   DtVrfSimOptions*  mySimOptions;

   DtCgf* myCgf;

#ifdef WIN32
   HWND              myConsoleWindow;

   // Writes diagnostics to vrfSim.log
   DtFilePrinter* myFilePrinter;
#endif

   // Publishes all diagnostics to network in comment interactions.
   DtBackendConsoleNetworkPrinter* myBackendConsoleNetworkPrinter;

   bool myWarnedFailedGetExitCode;

   static bool theUserRequestedShutdown;
   static DtVrfApp* theApp;
};