exampleTacticalGraphics

Table of Contents

• Overview
• Expected Result
• Example details
• Building the Example
• Running the Example
• Example Source Files
• DtExampleTacticalGraphicsDriver.h
• DtExampleTacticalGraphicsDriver.cxx
• exampleTacticalGraphics.h
• exampleTacticalGraphics.cxx

Overview

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

Expected Result

Tactical Graphics Stealth Result

Tactical Graphics PVD Result

Example details

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() );

            }
         }
      }

      DtAreaFacadeBase*  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()

Building the Example

VR-Vantage includes pre-built versions of the example plug-in. To build it yourself, follow the instructions at Building VR-Vantage Examples, Applications, and Plug-ins.

Running the Example

This example is a plug-in. You can run it by running ./bin64/exampleAccessory_stealth.bat (on Windows from cmd.exe) or ./bin64/exampleAccessory_stealth.sh (on Linux). For more information about running examples, please see Running Applications and Examples.

Example Source Files

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

---

DtExampleTacticalGraphicsDriver.h

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


#pragma once

#include <exampleTacticalGraphics.h>

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

namespace makVrv
{
   class DtLineFacadeBase;
   class DtAreaFacadeBase;
   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,
            DtLineFacadeBase* lineFacade);
         virtual void registerTacticalGraphic( const std::string& name,
            DtAreaFacadeBase* areaFacade);
         virtual void registerTacticalGraphic( const std::string& name,
            DtEntity2dFacade* sym2525bFacade);


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


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

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

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

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

         virtual void createAreaFacades();

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

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

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


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

      protected:
         bool myCreateFacades;

         std::vector<DtLineFacadeBase*> myLineFacades;

         std::vector<DtAreaFacadeBase*> myAreaFacades;

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

DtExampleTacticalGraphicsDriver.cxx

/*****************************************************************************
 * Copyright (c) 2019 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/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<DtLineFacadeBase*>::iterator lineIter = myLineFacades.begin();

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

         myLineFacades.clear();

         std::vector<DtAreaFacadeBase*>::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;
      }

      DtLineFacadeBase*  DtExampleTacticalGraphicsDriver::createSimpleLineFacade(int modelSet, std::vector<DtVector> pointVector)
      {
         DtLineFacadeBase* 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;
      }

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

         lineFacadeInterface->setLineStyle(vrvTacticalGraphicUtilities::AirAxis);

         lineFacadeInterface->setArrowSize(25.0);

         return lineFacadeInterface;
      }

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

         lineFacadeInterface->setModelDefinition("fort");

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

         return lineFacadeInterface;
      }

      DtLineFacadeBase*  DtExampleTacticalGraphicsDriver::createLineWithArrow(int modelSet, std::vector<DtVector> pointVector)
      {
         DtLineFacadeBase* 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,
         DtLineFacadeBase* 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);
         reportElementAttribute(lineFacade->uniqueId(), new DtElementAttributeDriverType("Tactical Graphics Driver"));

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

      void DtExampleTacticalGraphicsDriver::registerTacticalGraphic( const std::string& displayName,
         DtAreaFacadeBase* 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 );
         reportElementAttribute(areaFacade->uniqueId(), new DtElementAttributeDriverType("Tactical Graphics Driver"));

         // 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 );
         reportElementAttribute(sym2525bFacade->uniqueId(), new DtElementAttributeDriverType("Tactical Graphics Driver"));

         // 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() );

            }
         }
      }

      DtAreaFacadeBase*  DtExampleTacticalGraphicsDriver::createSimpleAreaFacade(int modelSet, std::vector<DtVector> pointVector)
      {
         DtAreaFacadeBase* 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;
      }

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

         areaFacadeInterface->setModelDefinition("fort");

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

         return areaFacadeInterface;
      }

      DtAreaFacadeBase*  DtExampleTacticalGraphicsDriver::createPatternFilledArea(int modelSet, std::vector<DtVector> pointVector)
      {
         DtAreaFacadeBase* 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) 2019 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) 2019 MAK Technologies, Inc.
 * All rights reserved.
 *****************************************************************************/


#include <exampleTacticalGraphics.h>

#include <vrvCoreQt/vrvCoreQt.h>

#include <vrvCore/DtVrvApplication.h>
#include <vrvCore/DtDriverManager.h>
#include <vrvCore/DtDe.h>
#include <vrvCore/DtDeMainWindow.h>
#include <vrvCoreQt/DtQtDeMainWindow.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);   

   // Don't show the startup dialog for selecting a terrain.
   DtDeMainWindow& mw = DtDeMainWindowProvider::instance(de).igMainWindow();
   DtQtDeMainWindow& mainWindow = dynamic_cast<DtQtDeMainWindow&>(mw);
   mainWindow.hideStartupDialog();

   // 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 );
}

[<< Examples] [Home] [Top of Page]