This section lists and describes two simple VR-Link applications. The first is a listen-only application that observes an exercise without simulating any entity on the network. The second is a write-only program that does not process information about remote entities.

Note: The source code for both examples is included with VR-Link.

2.9.1 A Listen-Only Example

The Listen-Only is an application that just listens to the network. This application can be compiled for either DIS or HLA. The only protocol-specific code is contained in the #if statement that starts at line 27.

With each iteration of the loop, the program prints an entity's updated, dead-reckoned position in topographic coordinates. In addition, if a fire PDU or interaction is detected on the network, the program prints a message showing the entity ID of the attacker.

#include <vl/exerciseConn.h>
#include <vl/exerciseConnInitializer.h>
#include <vlutil/vlProcessControl.h>
#include <vl/reflectedEntityList.h>
#include <vl/entityStateRepository.h>
#include <vl/reflectedEntity.h>
#include <vl/fireInteraction.h>
#include <vl/topoView.h>
#include <iostream>

int keybrdTick(void);

// Define a callback to process fire interactions.
void fireCb(DtFireInteraction* fire, void* /*usr*/)
{
  std::cout << "Fire Interaction from " 
        <<  fire->attackerId().string() << std::endl;
}

int main(int argc, char** argv)
{
  try
  {
     // Create a connection to the exercise or federation execution.
     DtVrlApplicationInitializer appInit(argc, argv, "VR-Link Listen");

     #if DtDIS
     appInit.setUseAsynchIO(true);
     #endif

     appInit.parseCmdLine();

     DtExerciseConn exConn(appInit);

     // Register a callback to handle fire interactions.
     DtFireInteraction::addCallback(&exConn, fireCb, NULL);

     // Create an object to manage entities that we hear about 
     // on the network.
     DtReflectedEntityList rel(&exConn);
   
     // Initialize VR-Link time.
     DtClock* clock = exConn.clock();

     int forever = 1;
     while (forever)
     {
        // Check if user hit 'q' to quit.
        if (keybrdTick() == -1)
           break;

        // Tell VR-Link the current value of simulation time.
        clock->setSimTime(clock->elapsedRealTime());

        // Process any incoming messages
        exConn.drainInput();

        // Find the first entity in the reflected entity list
        DtReflectedEntity *first = rel.first();

        if (first)
        {
           // Grab its state repository, where we can inspect its data.
           DtEntityStateRepository *esr = first->entityStateRep();

           // Create a topographic view on the state repository, so we 
           // can look at position information in topographic
           // coordinates.
           double refLatitude  = DtDeg2Rad(  35.699760);
           double refLongitude = DtDeg2Rad(-121.326577);
           DtTopoView topoView(esr, refLatitude, refLongitude);
  
           // Print the position.
           // Since it returns a DtString, we need to force it to 
           // const char* with a cast.
           std::cout << "Position of first entity: "
              <<  topoView.location().string() << std::endl;
        }
     
        // Sleep till next iteration.
        DtSleep(0.1);
     }
     return 0;
  }
  DtCATCH_AND_WARN(std::cout);
}

int keybrdTick()
{
  char *keyPtr = DtPollBlockingInputLine();
  if (keyPtr && (*keyPtr == 'q' || *keyPtr == 'Q')) 
     return -1;  
  else
     return 0;
}

2.9.2.1 Connecting to An Exercise

In lines 22-25, the program creates an exercise connection (DtExerciseConn). This connection serves as the program's interface to an exercise. DtExerciseConn has several constructors. In this example, we create a DtVrlApplicationInitializer and pass it to the DtExerciseConn. Use of a DtVrlApplicationInitializer provides support for command line arguments. The default protocol-specific initialization values are set in the

DtVrlApplicationInitializer and its base class, DtExerciseConnInitializer. This is the only protocol-specific part of the code.

If you want to specify initialization values in the DtExerciseConn, you would use code similar to the following:

int main()
{
   // Create a connection to the exercise or federation execution
#if DtHLA
   DtString execName("VR-Link");
   DtString fedName("VR-Link listen"); 
   DtExerciseConn exConn(execName, fedName, new DtSimpleRprFomMapper);
#elif DtDIS
   int port           = 3000;
   int exerciseId     = 1; 
   int siteId         = 1;
   int applicationNum = 15;
   DtExerciseConn exConn(port, exerciseId, siteId, applicationNum,
                              0,             // No Status, any error will be fatal
                              true);            // use Async IO
#endif 

2.9.1.2 Managing State and Interaction Information

Applications based on VR-Link typically use callbacks to handle incoming interactions such as fire, detonations, and collisions. For example, a callback named fireCb is registered with the DtFireInteraction class at line 36. This callback (defined at line 14) prints a message containing the attacker ID. It executes whenever the exercise connection receives a Fire PDU or interaction during a call to drainInput().

2.9.1.3 Tracking Entities

We create a reflected entity list in line 40 to keep track of entities found on the network. The entity list tracks the arrival and departure of entities, performs dead reckoning, manages time outs, and performs other entity-tracking tasks.

2.9.1.4 Managing Time

On line 43 we obtain a pointer to the simulation clock from the exercise connection.

2.9.1.5 Listening to the Network

At the start of each iteration, the program sets VR-Link simulation time (line 53) to provide a common time value for use by time-related operations that occur within an iteration of the loop (such as the dead-reckoning of multiple entities).

The drainInput() call (line 56) reads and processes any messages arriving through the exercise connection. This call triggers the execution, if needed, of any callbacks you have registered for that exercise connection.

In line 59, the program finds the first entity in the entity list, then in line 64, retrieves the pointer to the entity's entity state repository. Line 71 creates a topographic view of that entity state repository, allowing us to retrieve its position data in topographic coordinates rather than geocentric. (Lines 69 and 70 hard code the coordinates for this example.)

Line 76 obtains and prints the dead-reckoned entity location.

2.9.2 A Send-Only Example

The Send-Only application simulates the flight of an F18 aircraft. The program begins by sending a fire PDU or HLA fire interaction. Thereafter, the F18 flies north for 10 seconds, updating its position by sending DIS entity state PDUs or HLA attribute updates.

#include <vl/exerciseConn.h>
#include <vl/exerciseConnInitializer.h>
#include <vl/topoView.h>
#include <vl/entityPublisher.h>
#include <vl/entityStateRepository.h>
#include <vl/fireInteraction.h>
#include <vl/iffPublisher.h>
#include <vlpi/EntityTypes.h>
 #include <vlutil/vlProcessControl.h>
#include <iostream>

int main(int argc, char** argv)
{

  try
  {
     // Create a connection to the exercise or federation execution.
     DtVrlApplicationInitializer appInit(argc, argv "VR-Link talk");

     // Change some defaults
     #if DtDIS
     appInit.setUseAsynchIO(true);
     #endif

     appInit.parseCmdLine();

     DtExerciseConn exConn(appInit);

     DtEntityType f18Type(DtPlatform, DtPlatformDomainAir,
        DtUnitedStates, DtFighter, DtF18, 0, 0);

     // Create an entity publisher for the entity we are simulating.
     DtEntityPublisher entityPub(f18Type, &exConn, DtDrDrmRvw,
        DtForceFriendly, DtEntityPublisher::guiseSameAsType()); 

     // Hold on to the entity's state repository, where we can set data.
     DtEntityStateRepository *esr = entityPub.entityStateRep();

     // Create a topographic view on the state repository, so we 
     // can set position information in topographic coordinates.
     double refLatitude  = DtDeg2Rad(  35.699760);
     double refLongitude = DtDeg2Rad(-121.326577);
     DtTopoView topoView(esr, refLatitude, refLongitude);
  
     // We can use the ESR to set state.
     esr->setMarkingText("VR-Link");
     topoView.setOrientation(DtTaitBryan(0.0, 0.0, 0.0));

     // Initialize VR-Link time.
     DtClock* clock = exConn.clock();
  
     DtVector position(0, 0, -100);
     DtVector velocity(20, 0, 0);

     // Send a Fire Interaction.
     DtFireInteraction fire;
     fire.setAttackerId(entityPub.globalId());
     exConn.sendStamped(fire);
  
     // Main loop
     DtTime dt = 0.05;
     DtTime simTime = 0;
     while (simTime <= 10.0)
     {
        // Tell VR-Link the current value of simulation time.
        clock->setSimTime(simTime);

        // Process any incoming messages.
        exConn.drainInput();

        // Set the current position information.
        topoView.setLocation(position);
        topoView.setVelocity(velocity);

        // Call tick, which insures that any data that needs to be 
        // updated is sent.
        entityPub.tick();
     
        // Set up for next iteration.
        position[0] += velocity[0] * dt;
        simTime     += dt;
     
        // Wait till real time equals simulation time of next step
        DtSleep(simTime - clock->elapsedRealTime()); 
     }
  
  }
  DtCATCH_AND_WARN(std::cout);
  return 0;
}

2.9.2.1 Connecting to An Exercise

Like the listen-only example, this program creates a DtExerciseConn to provide an interface to the RTI or DIS network (lines 17 through 27).

2.9.2.2 Managing Entities

Line 29 defines the entity type the F18 will use.

To be visible to other applications in the exercise, each locally-simulated entity requires a DtEntityPublisher, created in line 33. The entity publisher manages the generation of messages for this particular entity. It provides an entity state repository where you can set state values, and a tick() function, which causes state information to be sent to the network if necessary.

Line 37 sets up a pointer to the entity state repository, then line 43 creates a topographic view on that repository. This lets us set the entity's positional data using topographic coordinates, rather than the default geocentric coordinates. (Lines 41 and 42 hard code the coordinates for this example.) Line 46 shows an example of storing a non-positional state value in the repository.

2.9.2.3 Sending Interactions

An example of sending an interaction appears in lines 56-58. You can send the interaction using the exercise connection's sendStamped() function.

Note: You can use sendStamped() to send state updates, but it is preferable to let the entity publisher send state updates for you, using data in the entity state repository, as shown in lines 72 through 77.

2.9.2.4 Sending State Messages

The main loop executes twenty times per second for ten seconds. As in the listen-only example, this program sets simulation time at the start of each iteration (line 66).

Note: While this program's main purpose is to demonstrate the sending of data to the network, it is not a true send-only application. Incoming data is also processed with the drainInput() call on line 69. This call is required for HLA, because this is where we tick the RTI.

The program updates the F18's positional data in its entity state repository in lines 72 and 73, and ticks the entity publisher in line 77 to send the updated data onto the network. Lines 72 and 73 set topographic coordinates through a view, which VR-Link converts to geocentric coordinates.

Thereafter, the only remaining tasks are to increment the F18's position, increment the simulation time, and sleep until it is time to begin the next iteration.

[<< Big and Little Endian Wire Formats] [Home] [Top of Page]

Table of Contents

2.9.1 A Listen-Only Example

2.9.2.1 Connecting to An Exercise

2.9.1.2 Managing State and Interaction Information

2.9.1.3 Tracking Entities

2.9.1.4 Managing Time

2.9.1.5 Listening to the Network

2.9.2 A Send-Only Example

2.9.2.1 Connecting to An Exercise

2.9.2.2 Managing Entities

2.9.2.3 Sending Interactions

2.9.2.4 Sending State Messages