exampleTacticalGraphics

This example demonstrates how to tactical graphics to the scene in a PVD application.

The example creates a DtExampleTacticalGraphicsDriver for creating line and area symbols that will be displayed on the Makland database.

The driver creates the symbol by waiting for the first application tick, then creating appropriate 2D or 3D line facades according to the model set realized. For the purposes of this example, only 2D (projected) areas are created.

      void DtExampleTacticalGraphicsDriver::createLineFacades()
      {
         DtModelSetRealizationManager::ModelSetRealizations::const_iterator iter;
         DtModelSetRealizationManager::ModelSetRealizations::const_iterator end;
         iter = myAgentManager.de().sharedState().modelSetRealizationManager().modelSetRealizations().begin();
         end = myAgentManager.de().sharedState().modelSetRealizationManager().modelSetRealizations().end();

         for ( ; iter != end; ++iter )
         {
            if ( iter->second )
            {
               myLineFacades.push_back(
                  createSimpleLineFacade(iter->first, 
                  convertToPointVector(sizeof(theSimpleLineVertices) / sizeof(DtVector), &theSimpleLineVertices[0])));
               registerTacticalGraphic( "Simple Line", myLineFacades.back() );


               myLineFacades.push_back(
                  createAirAxisLine(iter->first, 
                  convertToPointVector(sizeof(theAirAxisVertices) / sizeof(DtVector), &theAirAxisVertices[0])));
               registerTacticalGraphic( "Air Axis", myLineFacades.back() );

               myLineFacades.push_back(
                  createLineWithArrow(iter->first, 
                  convertToPointVector(sizeof(theLineWithArrow) / sizeof(DtVector), &theLineWithArrow[0])));
               registerTacticalGraphic( "Arrow", myLineFacades.back() );

               myLineFacades.push_back(
                  createFortifiedLine(iter->first, 
                  convertToPointVector(sizeof(theFortifiedLine) / sizeof(DtVector), &theFortifiedLine[0])));
               registerTacticalGraphic( "Fortified Line", myLineFacades.back() );

            }
         }
      }

      DtAreaFacadeInterface*  DtExampleTacticalGraphicsDriver::createSimpleAreaFacade(int modelSet, std::vector<DtVector> pointVector)

      void DtExampleTacticalGraphicsDriver::createAreaFacades()
      {
         DtModelSetRealizationManager::ModelSetRealizations::const_iterator iter;
         DtModelSetRealizationManager::ModelSetRealizations::const_iterator end;
         iter = myAgentManager.de().sharedState().modelSetRealizationManager().modelSetRealizations().begin();
         end = myAgentManager.de().sharedState().modelSetRealizationManager().modelSetRealizations().end();

         for ( ; iter != end; ++iter )
         {
            if ( iter->second )
            {
               myAreaFacades.push_back(
                  createSimpleAreaFacade(iter->first, 
                  convertToPointVector(sizeof(theSimpleAreaVertices) / sizeof(DtVector), &theSimpleAreaVertices[0])));
               registerTacticalGraphic( "Simple Area", myAreaFacades.back() );

               myAreaFacades.push_back(
                  createFortifiedArea(iter->first, 
                  convertToPointVector(sizeof(theFortifiedAreaVertices) / sizeof(DtVector), &theFortifiedAreaVertices[0])));
               registerTacticalGraphic( "Fortified Area", myAreaFacades.back() );

               myAreaFacades.push_back(
                  createPatternFilledArea(iter->first, 
                  convertToPointVector(sizeof(thePatternFilledAreaVertices) / sizeof(DtVector), &thePatternFilledAreaVertices[0])));
               registerTacticalGraphic( " Filled Area", myAreaFacades.back() );

            }
         }
      }

      bool DtExampleTacticalGraphicsDriver::onTick()

• DtExampleTacticalGraphicsDriver.h
• DtExampleTacticalGraphicsDriver.cxx
• exampleTacticalGraphics.h
• exampleTacticalGraphics.cxx

---

DtExampleTacticalGraphicsDriver.h

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


#pragma once

#include <exampleTacticalGraphics.h>

#include <vrvCore/DtDriver.h>
#include <vrvCore/DtTacticalGraphicOverlayManager.h>

class DtVector;

namespace makVrv
{
   class DtLineFacadeInterface;
   class DtAreaFacadeInterface;
   class DtEntity2dFacade;
   class DtTacticalGraphicOverlay;

   namespace exampleTacticalGraphics
   {
      class DT_DLL_EXAMPLESTACTICALGRAPHICS DtExampleTacticalGraphicsDriver
         : public makVrv::DtDriver
      {
      public:

         DtExampleTacticalGraphicsDriver( makVrv::DtAgentManager& am );

         virtual ~DtExampleTacticalGraphicsDriver();



         virtual const std::string& className() const;

         virtual bool onStart();

         virtual bool onStop();

         virtual bool onTick();



         virtual void createLineFacades();

         virtual void createOverlays();

         virtual void registerTacticalGraphic( const std::string& name,
            DtLineFacadeInterface* lineFacade);
         virtual void registerTacticalGraphic( const std::string& name,
            DtAreaFacadeInterface* areaFacade);
         virtual void registerTacticalGraphic( const std::string& name,
            DtEntity2dFacade* sym2525bFacade);


         virtual void slot_tacticalGraphicVisibilityChanged( 
            const DtUniqueID& id, bool flag );


         virtual DtLineFacadeInterface* createSimpleLineFacade(int modelSet, std::vector<DtVector> pointVector);

         virtual DtLineFacadeInterface* createAirAxisLine(int modelSet, std::vector<DtVector> pointVector);

         virtual DtLineFacadeInterface* createLineWithArrow(int modelSet, std::vector<DtVector> pointVector);

         virtual DtLineFacadeInterface* createFortifiedLine(int modelSet, std::vector<DtVector> pointVector);

         virtual void createAreaFacades();

         virtual DtAreaFacadeInterface* createSimpleAreaFacade(int modelSet, std::vector<DtVector> pointVector);

         virtual DtAreaFacadeInterface* createFortifiedArea(int modelSet, std::vector<DtVector> pointVector);

         virtual DtAreaFacadeInterface* createPatternFilledArea(int modelSet, std::vector<DtVector> pointVector);


      protected:
         virtual void slot_displayEngineAdded( const makVrv::DtDeRecord& igRecord );

      protected:
         bool myCreateFacades;

         std::vector<DtLineFacadeInterface*> myLineFacades;

         std::vector<DtAreaFacadeInterface*> myAreaFacades;

         std::vector<DtEntity2dFacade*> my2525bFacades;
      };
   }
}

DtExampleTacticalGraphicsDriver.cxx

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


#include <DtExampleTacticalGraphicsDriver.h>

#include <vrvCore/DtDe.h>
#include <vrvCore/DtScene.h>
#include <vrvCore/DtAgentManager.h>
#include <vrvCore/DtModelSetRealizationManager.h>
#include <vrvCore/DtDeSharedState.h>
#include <vrvCore/Dt2DLineFacade.h>
#include <vrvCore/Dt3DLineFacade.h>
#include <vrvCore/Dt2DAreaFacade.h>
#include <vrvCore/DtEntity2dFacade.h>
#include <vrvCore/DtEntity2dFacade.inl>

#include <vrvCore/DtTacticalGraphicOverlay.h>
#include <vrvCore/DtTacticalGraphicOverlayManager.h>
#include <vrvCore/DtElementAttributes.h>

#include <vrvUtil/DtCoordinateConverter.h>
#include <vrvUtil/DtCoordinateSystem.h>

#include <matrix/vlVector.h>

namespace makVrv
{

   namespace exampleTacticalGraphics
   {
      enum ModelSets
      {
         ModelSet_3D = 0,
         ModelSet_3DColorized = 1,
         ModelSet_2DIcons = 5,
      };


      static DtVector theSimpleLineVertices[] = {
         DtVector(2811.45, 3429.92, 10.0), DtVector(2837.62, 3429.92, 10.0),
         DtVector(2852.64, 3445.10, 10.0), DtVector(2877.22, 3445.53, 10.0)
      };

      static DtVector theAirAxisVertices[] = {
         DtVector(624.67, 914.33, 1000.0), DtVector(1438.62, 928.41, 1212.05),
         DtVector(2418.68, 1204.80, 1125.62)
      };

      static DtVector theLineWithArrow[] = {
         DtVector(1286.91, 1040.0, 190.0), DtVector(1454.0, 1040.0, 190.0)
      };

      static DtVector theFortifiedLine[] = {
         DtVector(2170.30, 1312.0, 119.0), DtVector(2217.71, 1217.85, 122.53),
         DtVector(2315.01, 1211.53, 124.79)
      };

      static DtVector theSimpleAreaVertices[] = {
         DtVector(1563.0, 943.0, 10.0), DtVector(1563.0, 895.0, 10.0),
         DtVector(1617.0, 895.0, 10.0), DtVector(1617.0, 943.0, 10.0)
      };

      static DtVector theFortifiedAreaVertices[] = {
         DtVector(1572.0, 1375.0, 260.0), DtVector(1572.0, 1320.0, 260.0),
         DtVector(1652.0, 1320.0, 260.0), DtVector(1652.0, 1375.0, 260.0)
      };

      static DtVector thePatternFilledAreaVertices[] = {
         DtVector(3000.0, 3700.0, 10.0), DtVector(3000.0, 3600.0, 10.0),
         DtVector(3050.0, 3600.0, 10.0), DtVector(3050.0, 3700.0, 10.0)
      };

      static bool is2D(int modelSet)
      {
         return ( modelSet == ModelSet_2DIcons );
      }

      static std::vector<DtVector> convertToPointVector(int numVertices, DtVector* pointVector)
      {
         int i;
         std::vector<DtVector> points;

         for (i = 0; i < numVertices; i++)
         {
            points.push_back(pointVector[i]);
         }

         return points;
      }

      DtExampleTacticalGraphicsDriver::DtExampleTacticalGraphicsDriver( DtAgentManager& am )
      : makVrv::DtDriver( am, "DtExampleSymbolDriver" )
      , myCreateFacades(true)
      {
      }

      DtExampleTacticalGraphicsDriver::~DtExampleTacticalGraphicsDriver()
      {
         DtExampleTacticalGraphicsDriver::onStop();
      }

      const std::string& DtExampleTacticalGraphicsDriver::className() const
      {
         static std::string name = "DtExampleTacticalGraphicsDriver";
         return name;
      }

      bool DtExampleTacticalGraphicsDriver::onStart()
      {
         // Load the Makland programatically.
         DtScene& sceneDriver = myAgentManager.de().scene();
         std::string maklandPath = myAgentManager.de().dePathConfiguration().userPath();
         maklandPath += "/terrains/Makland.mtf";
         sceneDriver.loadTerrain( maklandPath );

         DtTacticalGraphicOverlayManager& tgOverlayMgr = 
            DtTacticalGraphicOverlayManager::instance( myAgentManager.de() );

         tgOverlayMgr.signal_tacticalGraphicVisibilityChanged.connect( boost::bind( 
            &DtExampleTacticalGraphicsDriver::slot_tacticalGraphicVisibilityChanged, this, _1, _2 ) );

         return true;
      }

      bool DtExampleTacticalGraphicsDriver::onStop()
      {
         std::vector<DtLineFacadeInterface*>::iterator lineIter = myLineFacades.begin();

         while (lineIter != myLineFacades.end())
         {
            delete *lineIter;
            ++lineIter;
         }

         myLineFacades.clear();

         std::vector<DtAreaFacadeInterface*>::iterator areaIter = myAreaFacades.begin();

         while (areaIter != myAreaFacades.end())
         {
            delete *areaIter;
            ++areaIter;
         }

         myAreaFacades.clear();

         DtTacticalGraphicOverlayManager& tgOverlayMgr = 
            DtTacticalGraphicOverlayManager::instance( myAgentManager.de() );

         tgOverlayMgr.signal_tacticalGraphicVisibilityChanged.disconnect( boost::bind( 
            &DtExampleTacticalGraphicsDriver::slot_tacticalGraphicVisibilityChanged, this, _1, _2 ) );

         return true;
      }

      DtLineFacadeInterface*  DtExampleTacticalGraphicsDriver::createSimpleLineFacade(int modelSet, std::vector<DtVector> pointVector)
      {
         DtLineFacadeInterface* lineFacadeInterface = 0;

         if (is2D(modelSet))
         {
            lineFacadeInterface = new Dt2DLineFacade(myAgentManager, modelSet, 0, false);
         }
         else
         {
            lineFacadeInterface = new Dt3DLineFacade(myAgentManager, modelSet, 0, false);
         }

         lineFacadeInterface->setLineWidth(4.0);

         lineFacadeInterface->setColor(1.0f, 0.0f, 0.0f, 0.777f);

         lineFacadeInterface->setSolid(true);

         lineFacadeInterface->setPoints(pointVector);

         return lineFacadeInterface;
      }

      DtLineFacadeInterface*  DtExampleTacticalGraphicsDriver::createAirAxisLine(int modelSet, std::vector<DtVector> pointVector)
      {
         DtLineFacadeInterface* lineFacadeInterface = createSimpleLineFacade(modelSet, pointVector);

         lineFacadeInterface->setLineStyle(vrvTacticalGraphicUtilities::AirAxis);

         lineFacadeInterface->setArrowSize(25.0);

         return lineFacadeInterface;
      }

      DtLineFacadeInterface*  DtExampleTacticalGraphicsDriver::createFortifiedLine(int modelSet, std::vector<DtVector> pointVector)
      {
         DtLineFacadeInterface* lineFacadeInterface = createSimpleLineFacade(modelSet, pointVector);

         lineFacadeInterface->setModelDefinition("fort");

         lineFacadeInterface->setColor(1.0f, 0.0f, 0.0f, 0.777f);

         return lineFacadeInterface;
      }

      DtLineFacadeInterface*  DtExampleTacticalGraphicsDriver::createLineWithArrow(int modelSet, std::vector<DtVector> pointVector)
      {
         DtLineFacadeInterface* lineFacadeInterface = createSimpleLineFacade(modelSet, pointVector);

         lineFacadeInterface->setSegmentEndArrow(pointVector.size() - 2, true);

         lineFacadeInterface->setArrowSize(25.0);

         return lineFacadeInterface;
      }

      void DtExampleTacticalGraphicsDriver::createOverlays()
      {
         DtTacticalGraphicOverlayManager::instance( myAgentManager.de() ).addOverlay( "Lines" );
         DtTacticalGraphicOverlayManager::instance( myAgentManager.de() ).addOverlay( "Areas" );
         DtTacticalGraphicOverlayManager::instance( myAgentManager.de() ).addOverlay( "Symbols" );
      }

      void DtExampleTacticalGraphicsDriver::registerTacticalGraphic( const std::string& displayName,
         DtLineFacadeInterface* lineFacade )
      {
         // Provide a model-set specific prefix for the name
         std::string prefix = "";
         switch( lineFacade->modelSet() )
         {
         case ModelSet_3D:
            prefix = "3D ";
            break;
         case ModelSet_3DColorized:
            prefix = "XR ";
            break;
         case ModelSet_2DIcons:
            prefix = "2D ";
            break; 
         }

         DtTacticalGraphicOverlay* overlay = DtTacticalGraphicOverlayManager::instance( myAgentManager.de() ).findOverlay("Lines");

         // Set the tactical graphic up as a DtElement; this is required for the graphic to show up in
         // the Overlay tree panel
         reportElementCreated(lineFacade->uniqueId(), (DtUniqueID)0, DtElementEntry::GraphicShape);
         DtElementAttributeDisplayName* name = new DtElementAttributeDisplayName( prefix + displayName );
         reportElementAttribute( lineFacade->uniqueId(), name );

         // Add the graphic to the overlay
         overlay->addGraphic( lineFacade->uniqueId() );
      }

      void DtExampleTacticalGraphicsDriver::registerTacticalGraphic( const std::string& displayName,
         DtAreaFacadeInterface* areaFacade)
      {
         // Provide a model-set specific prefix for the name
         std::string prefix = "";
         switch( areaFacade->modelSet() )
         {
         case ModelSet_3D:
            prefix = "3D ";
            break;
         case ModelSet_3DColorized:
            prefix = "XR ";
            break;
         case ModelSet_2DIcons:
            prefix = "2D ";
            break; 
         }

         DtTacticalGraphicOverlay* overlay = DtTacticalGraphicOverlayManager::instance( myAgentManager.de() ).findOverlay("Areas");
         // Set the tactical graphic up as a DtElement; this is required for the graphic to show up in
         // the Overlay tree panel
         reportElementCreated(areaFacade->uniqueId(), (DtUniqueID)0, DtElementEntry::GraphicShape);
         DtElementAttributeDisplayName* name = new DtElementAttributeDisplayName( prefix + displayName );
         reportElementAttribute( areaFacade->uniqueId(), name );

         // Add the graphic to the overlay
         overlay->addGraphic( areaFacade->uniqueId() );
      }

      void DtExampleTacticalGraphicsDriver::registerTacticalGraphic( const std::string& displayName, DtEntity2dFacade* sym2525bFacade)
      {
         // Provide a model-set specific prefix for the name
         std::string prefix = "";
         switch( sym2525bFacade->modelSet() )
         {
         case ModelSet_3D:
            prefix = "3D ";
            break;
         case ModelSet_3DColorized:
            prefix = "XR ";
            break;
         case ModelSet_2DIcons:
            prefix = "2D ";
            break; 
         }

         DtTacticalGraphicOverlay* overlay = DtTacticalGraphicOverlayManager::instance( myAgentManager.de() ).findOverlay("Symbols");
         // Set the tactical graphic up as a DtElement; this is required for the graphic to show up in
         // the Overlay tree panel
         reportElementCreated(sym2525bFacade->uniqueId(), (DtUniqueID)0, DtElementEntry::GraphicPoint);
         DtElementAttributeDisplayName* name = new DtElementAttributeDisplayName( prefix + displayName );
         reportElementAttribute( sym2525bFacade->uniqueId(), name );

         // Add the graphic to the overlay
         overlay->addGraphic( sym2525bFacade->uniqueId() );
      }

      void DtExampleTacticalGraphicsDriver::slot_tacticalGraphicVisibilityChanged( 
         const DtUniqueID& id, bool flag )
      {
         // find the graphic and set its visibility
         for( int lCount = 0; lCount < myLineFacades.size(); ++lCount )
         {
            if ( myLineFacades[lCount]->uniqueId() == id )
            {
               myLineFacades[lCount]->setVisible( flag );
               return;
            }
         }
         for( int aCount = 0; aCount < myAreaFacades.size(); ++aCount )
         {
            if ( myAreaFacades[aCount]->uniqueId() == id )
            {
               myAreaFacades[aCount]->setVisible( flag );
               return;
            }
         }

      }

      void DtExampleTacticalGraphicsDriver::createLineFacades()
      {
         DtModelSetRealizationManager::ModelSetRealizations::const_iterator iter;
         DtModelSetRealizationManager::ModelSetRealizations::const_iterator end;
         iter = myAgentManager.de().sharedState().modelSetRealizationManager().modelSetRealizations().begin();
         end = myAgentManager.de().sharedState().modelSetRealizationManager().modelSetRealizations().end();

         for ( ; iter != end; ++iter )
         {
            if ( iter->second )
            {
               myLineFacades.push_back(
                  createSimpleLineFacade(iter->first, 
                  convertToPointVector(sizeof(theSimpleLineVertices) / sizeof(DtVector), &theSimpleLineVertices[0])));
               registerTacticalGraphic( "Simple Line", myLineFacades.back() );


               myLineFacades.push_back(
                  createAirAxisLine(iter->first, 
                  convertToPointVector(sizeof(theAirAxisVertices) / sizeof(DtVector), &theAirAxisVertices[0])));
               registerTacticalGraphic( "Air Axis", myLineFacades.back() );

               myLineFacades.push_back(
                  createLineWithArrow(iter->first, 
                  convertToPointVector(sizeof(theLineWithArrow) / sizeof(DtVector), &theLineWithArrow[0])));
               registerTacticalGraphic( "Arrow", myLineFacades.back() );

               myLineFacades.push_back(
                  createFortifiedLine(iter->first, 
                  convertToPointVector(sizeof(theFortifiedLine) / sizeof(DtVector), &theFortifiedLine[0])));
               registerTacticalGraphic( "Fortified Line", myLineFacades.back() );

            }
         }
      }

      DtAreaFacadeInterface*  DtExampleTacticalGraphicsDriver::createSimpleAreaFacade(int modelSet, std::vector<DtVector> pointVector)
      {
         DtAreaFacadeInterface* areaFacadeInterface = 0;

         areaFacadeInterface = new Dt2DAreaFacade(myAgentManager, modelSet, 0, false);

         areaFacadeInterface->setLineWidth(4.0);

         areaFacadeInterface->setColor(0.0f, 1.0f, 0.0f, 0.777f);

         areaFacadeInterface->setPoints(pointVector);

         return areaFacadeInterface;
      }

      DtAreaFacadeInterface*  DtExampleTacticalGraphicsDriver::createFortifiedArea(int modelSet, std::vector<DtVector> pointVector)
      {
         DtAreaFacadeInterface* areaFacadeInterface = createSimpleAreaFacade(modelSet, pointVector);

         areaFacadeInterface->setModelDefinition("fort");

         areaFacadeInterface->setColor(0.0f, 1.0f, 0.0f, 0.777f);

         return areaFacadeInterface;
      }

      DtAreaFacadeInterface*  DtExampleTacticalGraphicsDriver::createPatternFilledArea(int modelSet, std::vector<DtVector> pointVector)
      {
         DtAreaFacadeInterface* areaFacadeInterface = createSimpleAreaFacade(modelSet, pointVector);

         areaFacadeInterface->setFillPattern(vrvTacticalGraphicUtilities::HorizontalLines);

         return areaFacadeInterface;
      }

      void DtExampleTacticalGraphicsDriver::createAreaFacades()
      {
         DtModelSetRealizationManager::ModelSetRealizations::const_iterator iter;
         DtModelSetRealizationManager::ModelSetRealizations::const_iterator end;
         iter = myAgentManager.de().sharedState().modelSetRealizationManager().modelSetRealizations().begin();
         end = myAgentManager.de().sharedState().modelSetRealizationManager().modelSetRealizations().end();

         for ( ; iter != end; ++iter )
         {
            if ( iter->second )
            {
               myAreaFacades.push_back(
                  createSimpleAreaFacade(iter->first, 
                  convertToPointVector(sizeof(theSimpleAreaVertices) / sizeof(DtVector), &theSimpleAreaVertices[0])));
               registerTacticalGraphic( "Simple Area", myAreaFacades.back() );

               myAreaFacades.push_back(
                  createFortifiedArea(iter->first, 
                  convertToPointVector(sizeof(theFortifiedAreaVertices) / sizeof(DtVector), &theFortifiedAreaVertices[0])));
               registerTacticalGraphic( "Fortified Area", myAreaFacades.back() );

               myAreaFacades.push_back(
                  createPatternFilledArea(iter->first, 
                  convertToPointVector(sizeof(thePatternFilledAreaVertices) / sizeof(DtVector), &thePatternFilledAreaVertices[0])));
               registerTacticalGraphic( " Filled Area", myAreaFacades.back() );

            }
         }
      }

      bool DtExampleTacticalGraphicsDriver::onTick()
      {
         if (myCreateFacades)
         {
            myCreateFacades = false;

            createOverlays();
            createLineFacades();
            createAreaFacades();

            float friendlyColor[4] = {0.5f, 224.0f / 255.0f, 1.0f, 0.8f };
            DtEntity2dFacade *sym2525bFacade = new DtEntity2dFacade( myAgentManager, 0, 0, false );
            sym2525bFacade->setPosition( DtVector( 624.67, 914.33, 1000.0 ) );
            sym2525bFacade->setIconModelDefinition("2525bIcons");
            sym2525bFacade->setOutlineGlyph(DtUnicodeChar((wchar_t)0x40C6));
            sym2525bFacade->setFillGlyph(DtUnicodeChar((wchar_t)0x0022));
            sym2525bFacade->setFillColor( friendlyColor ); 
            my2525bFacades.push_back(sym2525bFacade);
            registerTacticalGraphic( "FA-18 Hornet", sym2525bFacade );

            sym2525bFacade = new DtEntity2dFacade( myAgentManager, 1, 0, false );
            sym2525bFacade->setPosition( DtVector( 624.67, 914.33, 1000.0 ) );
            sym2525bFacade->setIconModelDefinition("2525bIcons");
            sym2525bFacade->setOutlineGlyph(DtUnicodeChar((wchar_t)0x40C6));
            sym2525bFacade->setFillGlyph(DtUnicodeChar((wchar_t)0x0022));
            sym2525bFacade->setFillColor( friendlyColor ); 
            my2525bFacades.push_back(sym2525bFacade);
            registerTacticalGraphic( "FA-18 Hornet", sym2525bFacade );

            sym2525bFacade = new DtEntity2dFacade( myAgentManager, 5, 0, false );
            sym2525bFacade->setPosition( DtVector( 624.67, 914.33, 1000.0 ) );
            sym2525bFacade->setIconModelDefinition("2525bIcons");
            sym2525bFacade->setOutlineGlyph(DtUnicodeChar((wchar_t)0x40C6));
            sym2525bFacade->setFillGlyph(DtUnicodeChar((wchar_t)0x0022));
            sym2525bFacade->setFillColor( friendlyColor ); 
            my2525bFacades.push_back(sym2525bFacade);
            registerTacticalGraphic( "FA-18 Hornet", sym2525bFacade );
         }
         return true;
      }

      void DtExampleTacticalGraphicsDriver::slot_displayEngineAdded( const DtDeRecord& igRecord )
      {
         // When a new display engine is connected to our driver, the driver
         // must be re-started in order to ensure the terrain and all symbols
         // are properly loaded on all connected De's.
         stop();
         start();
      }
   }
}

exampleTacticalGraphics.h

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


#pragma once

// Plugin export macro.
#ifdef _WIN32
#  ifdef EXAMPLETACTICALGRAHICS_EXPORTS
#     define DT_DLL_EXAMPLESTACTICALGRAPHICS __declspec ( dllexport )
#  else
#     define DT_DLL_EXAMPLESTACTICALGRAPHICS __declspec ( dllimport )
#  endif
#else
#  define DT_DLL_EXAMPLESTACTICALGRAPHICS
#endif

// Declare & export the plugin initialization function (bool initDeModule(DtDe* de))
#define DT_DE_PLUGIN_EXPORT_MACRO DT_DLL_EXAMPLESTACTICALGRAPHICS
#include <vrvCore/exportPlugin.h>

// Plugin initialization methods.
DT_DLL_EXAMPLESTACTICALGRAPHICS bool initDeModule( makVrv::DtDe* de );
DT_DLL_EXAMPLESTACTICALGRAPHICS void init( makVrv::DtDe& de );
DT_DLL_EXAMPLESTACTICALGRAPHICS void installDriver( makVrv::DtDe& de );

exampleTacticalGraphics.cxx

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


#include <exampleTacticalGraphics.h>

#include <vrvCoreQt/vrvCoreQt.h>
#include <vrvOsgEarthQt/vrvOsgEarthQt.h>
#include <vrvOsgEarthQt/DtOsgEarthStartupManager.h>

#include <vrvCore/DtVrvApplication.h>
#include <vrvCore/DtDriverManager.h>
#include <vrvCore/DtDe.h>

#include <DtExampleTacticalGraphicsDriver.h>

// Use the VR-Vantage namespace.
// All classes in VR-Vantage are in this namespace.
using namespace makVrv;

using namespace makVrv::exampleTacticalGraphics;

bool initDeModule( DtDe* de )
{
   // Setup the plug-in.
   init( *de );
   return true;
}

void init( DtDe& de )
{
   // Ensure that init only gets called once
   // (not strictly necessary here, but this is good practice in general)
   DT_DE_INIT_ONCE( de );

   // Make sure that the vrvCoreQt and vrvOsgEarthQt module are init'ed.
   vrvCoreQt::init(de);
   vrvOsgEarthQt::init(de);

   // Don't show the startup dialog for selecting a terrain.
   DtOsgEarthStartupManager::instance(de).setShowStartupDialog( false );

   // We only want to create the driver if we are running in master mode.
   if ( de.isInMasterMode() )
   {
      // The accessory must be created after the DE's initialization is
      // finished, to make sure all the objects it uses exist.
      de.signal_postInitialize.connect( boost::bind(
         &installDriver, boost::ref(de) ) );
   }
}

void installDriver( DtDe& de )
{
   // Create DtExampleDriver.
   DtExampleTacticalGraphicsDriver* driver = new DtExampleTacticalGraphicsDriver( de.agentManager() );

   // The driver is now owned by the display engine. Do not delete it.
   de.driverManager().addDriver( driver );

   // Start the driver, creating the agent.
   de.driverManager().startDriver( driver );
}