VR-Forces 4.0.4 Class Documentation: exampleVisualDefinitionSet

By using this example, you will learn:

How to add menu items into the system
How to subclass an existing visualizer and add your own functionality to it
How to create an entity to visualizer from a visualizer set
How to place an entity into the scene

The code fragments are from exampleVisualDefinitionSetPluginInit.cxx code.

      void postInitialize(DtDe& de)
      {
         de.signal_preTick.disconnect(boost::bind(&postInitialize, _1));
         DtStateVisualizerFactory::instance(de).addStateVisualizerCreator(de,
            new DtExampleIndicatorVisualizerCreator);
      }

      void init(DtDe& de)
      {
         DT_DE_INIT_ONCE(de);

         // First make sure that the vrvCoreQt module is init'ed.
         vrvCoreQt::init(de);

         // Register the DtExampleMenu.
         DtQtMenuAssembler::instance(de).registerMenu(new DtExampleMenu(de));

         //Add example menu and example page item.
         makVrv::DtVrvApplication* igApp = makVrv::DtVrvApplication::findFromDe(de);
         if(igApp)
         {
            igApp->masterModeMenuConfiguration().addMenuPath(
               makVrv::DtMenuPath::mainMenu("DtExampleMenu"));               
            igApp->masterModeMenuConfiguration().addMenuPath(
               makVrv::DtMenuPath::mainMenu("DtExampleMenu").item("DtCreateObjectMenuItem"));

            DtQtMenuAssembler::instance(de).registerMenu(new DtExampleMenu(de));
            DtQtMenuAssembler::instance(de).registerMenu(new DtCreateObjectMenuItem(de));

Implement the functionality to create the entity from visualizers

   void DtCreateObjectMenuItem::on_triggered()

Create the indicator visualizer to display the information about the associated entity.

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 ./bin/exampleVisualDefinitionSet_stealth.bat (on Windows) or ./bin/exampleVisualDefinitionSet_stealth.sh (on Linux). For more information about running examples, please see Running Applications and Examples.

Example Source Files

DtExampleIndicatorVisualizer.cxx

/******************************************************************************
** Copyright (c) 2009 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: DtExampleIndicatorVisualizer.cxx,v $ $Revision: 1.43 $ $State: Exp $
******************************************************************************/


#include "DtExampleIndicatorVisualizer.h"
#include <vrvCore/DtEntityStateListener.h>

#include <boost/bind.hpp>

#include <matrix/geodCoord.h>

#include <stdio.h>

namespace makVrv
{
   namespace vrvExampleVisualDefinitionSetPlugin
   {

      DtExampleIndicatorVisualizer::DtExampleIndicatorVisualizer(DtBaseConnection& simulation, DtStateListener& listener, int modelSet)
      : DtEntityIndicatorVisualizer(simulation, listener, modelSet)
      , myEntityListener(dynamic_cast<DtEntityStateListener*>(&listener))
      {
         myConnections.manageConnection(
            myEntityListener->signal_velocitySet.connect(boost::bind(&DtExampleIndicatorVisualizer::setUpdateInfo,this, true)));
         myConnections.manageConnection(
            myEntityListener->signal_locationSet.connect(boost::bind(&DtExampleIndicatorVisualizer::setUpdateInfo,this, true)));
         myConnections.manageConnection(
            myEntityListener->signal_orientationSet.connect(boost::bind(&DtExampleIndicatorVisualizer::setUpdateInfo,this, true)));
      }

      DtExampleIndicatorVisualizer::~DtExampleIndicatorVisualizer()
      {
      }

      void DtExampleIndicatorVisualizer::setUpdateInfo(bool b)
      {
         DtEntityIndicatorVisualizer::setUpdateInfo(b);

         postUpdate();
      }

      DtUnicode DtExampleIndicatorVisualizer::generateInfoString() const
      {
         const char* entityFormatString = 
            "Speed   :%.2f m/s\n" //Speed
            "Heading :%.2f Deg\n" //Heading
            "Location(x, y, z) :%.3f, %.3f, %.1f m above sea level\n";

         std::string buffer;
         buffer.resize(1024,'0');

         int charsWritten = sprintf(const_cast<char*>(buffer.c_str()),entityFormatString,
            sqrtf((float)myEntityListener->velocity().magnitudeSquared()),
            DtRad2Deg(myEntityListener->orientation().psi()),
            myEntityListener->location().x(), myEntityListener->location().y(), myEntityListener->location().z()
            );
         buffer.resize(charsWritten,'0');

         return DtUnicode::fromAscii(buffer);
      }
   }
}

DtExampleIndicatorVisualizer.h

/******************************************************************************
** Copyright (c) 2009 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: DtExampleIndicatorVisualizer.h,v $ $Revision: 1.43 $ $State: Exp $
******************************************************************************/


#ifndef DtExampleIndicatorVisualizer_H_
#define DtExampleIndicatorVisualizer_H_

#include <vrvCore/DtEntityIndicatorVisualizer.h>

namespace makVrv
{
   class DtEntityStateListener;

   namespace vrvExampleVisualDefinitionSetPlugin
   {
      class DtExampleIndicatorVisualizer : public DtEntityIndicatorVisualizer
      {
      public:
         DtExampleIndicatorVisualizer(DtBaseConnection& simulation, DtStateListener& listener, int modelSet);

         virtual ~DtExampleIndicatorVisualizer();

         virtual DtUnicode generateInfoString() const;

      protected:
         virtual void setUpdateInfo(bool);

      protected:

         DtEntityStateListener*  myEntityListener;
      };

      typedef DtStateVisualizerCreatorTemplate<DtExampleIndicatorVisualizer> DtExampleIndicatorVisualizerCreator;
   }
}

#endif

exampleVisualDefinitionSetPluginInit.cxx

/******************************************************************************
** Copyright (c) 2009 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: exampleVisualDefinitionSetPluginInit.cxx,v $ $Revision: 1.3 $ $State: Exp $
******************************************************************************/


#include "exampleVisualDefinitionSetPlugin.h"
#include "exampleVisualDefinitionSetPluginInit.h"
#include "DtExampleIndicatorVisualizer.h"
#include "DtExampleMenu.h"

#include <vrvCoreQt/DtQtMenuAssembler.h>
#include <vrvCore/DtVrvApplication.h>
#include <vrvCore/DtDe.h>

#include <vrvCore/DtStateVisualizerFactory.h>
#include <vrvCore/DtWriteSettingsLock.h>

bool initDeModule(makVrv::DtDe* de)
{
   makVrv::vrvExampleVisualDefinitionSetPlugin::init(*de);
   return true;
}

namespace makVrv
{
   namespace vrvExampleVisualDefinitionSetPlugin
   {
      void postInitialize(DtDe& de)
      {
         de.signal_preTick.disconnect(boost::bind(&postInitialize, _1));
         DtStateVisualizerFactory::instance(de).addStateVisualizerCreator(de,
            new DtExampleIndicatorVisualizerCreator);
      }

      void init(DtDe& de)
      {
         DT_DE_INIT_ONCE(de);

         // First make sure that the vrvCoreQt module is init'ed.
         vrvCoreQt::init(de);

         // Register the DtExampleMenu.
         DtQtMenuAssembler::instance(de).registerMenu(new DtExampleMenu(de));

         //Add example menu and example page item.
         makVrv::DtVrvApplication* igApp = makVrv::DtVrvApplication::findFromDe(de);
         if(igApp)
         {
            igApp->masterModeMenuConfiguration().addMenuPath(
               makVrv::DtMenuPath::mainMenu("DtExampleMenu"));               
            igApp->masterModeMenuConfiguration().addMenuPath(
               makVrv::DtMenuPath::mainMenu("DtExampleMenu").item("DtCreateObjectMenuItem"));

            DtQtMenuAssembler::instance(de).registerMenu(new DtExampleMenu(de));
            DtQtMenuAssembler::instance(de).registerMenu(new DtCreateObjectMenuItem(de));

            de.signal_preTick.connect(boost::bind(postInitialize, _1));
         }
      }
   }
}

DtExampleMenu.cxx

/******************************************************************************
** Copyright (c) 2008 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: DtExampleMenu.cxx,v $ $Revision: 1.1 $ $State: Exp $
******************************************************************************/


#include "DtExampleMenu.h"

#include <vrvCore/DtAttachManager.h>
#include <vrvCore/DtDe.h>
#include <vrvCore/DtDeSharedState.h>
#include <vrvCore/DtDriverManager.h>
#include <vrvCore/DtEntityFacade.h>
#include <vrvCore/DtInputDriver.h>
#include <vrvCore/DtIntersector.h>
#include <vrvCore/DtModelDefinitionManager.h>
#include <vrvCore/DtObserver.h>
#include <vrvCore/DtObserverModeManager.h>
#include <vrvCore/DtScene.h>
#include <vrvCore/DtTerrain.h>
#include <vrvCore/DtTerrainPatch.h>
#include <vrvCore/DtTerrainPatchObject.h>
#include <vrvCore/DtTerrainPatchObjectAgent.hpp>

#include <vrvCore/DtVisualizerAttribute.h>
#include <vrvCore/DtVisualizerDefinition.h>
#include <vrvCore/DtVisualizerDefinitionSet.h>
#include <vrvCore/DtBuiltInSchemas.h>
#include <vrvCore/DtVisualizerSchema.h>

#include <vrvUtil/DtCoordinateConverter.h>
#include <vrvUtil/DtCoordinateSystem.h>
#include <vrvVrl/DtEntityTypeMapper.h>
#include <vrvVrl/DtSharedSimulationSettings.h>

#include <vlpi/entityType.h>
#include <QtGui/QMenu>


namespace makVrv
{
   DtExampleMenu::DtExampleMenu(DtDe& de)
   : DtMenu(de, std::string("DtExampleMenu"))
   {
   }

   DtExampleMenu::~DtExampleMenu()
   {
   }

   QMenu* DtExampleMenu::createMenu( DtDe&, QWidget* parent )
   {
      QMenu* menu = new QMenu(QMenu::tr("&Examples"),parent);
      return menu;
   }

   DtCreateObjectMenuItem::DtCreateObjectMenuItem(DtDe& de)
   : DtMenuItem(std::string("DtCreateObjectMenuItem"))
   , myDe(de)
   {
      myRandomNumberGenerator.setSeed(time(0));
   }

   DtCreateObjectMenuItem::~DtCreateObjectMenuItem()
   {

   }

   void DtCreateObjectMenuItem::on_aboutToShow()
   {
      myAction->setEnabled(myDe.scene().terrain().terrainPatches().size() != 0);
   }

   QAction* DtCreateObjectMenuItem::createAction( DtDe&, QWidget* parent )
   {
      myAction = new QAction(parent);
      myAction->setText(DtMenuItem::tr("&Create"));

      return myAction;
   }

   const DtUnicode* DtCreateObjectMenuItem::chooseRandomString(const std::vector<DtUnicode>& definitions)
   {
      size_t s = definitions.size();
      if(s == 0)
      {
         return 0;
      }
      else if(s == 1)
      {
         return &(definitions.front());
      }
      else
      {
         int index = myRandomNumberGenerator.generate(0,s-1);
         return &(definitions[index]);
      }
   } 
     
   DtUnicode DtCreateObjectMenuItem::modelDefFromVisualSet( const DtVisualizerDefinitionSet& set )
   {
      std::vector<const DtVisualizerDefinition*> defs;
      set.findVisualizerDefinitions(DtBuiltInSchemas::theDtModelSchema().name(),defs);
      if(defs.size() == 0)
      {
         return DtUnicode();
      }

      const DtVisualizerDefinition* visDef = defs.front();
      if ( visDef ) 
      {
         const DtVisualizerAttribute* attr = visDef->findAttribute("modeldefinition");
         const DtVisualizerAttributeStringVector* multiDefs = dynamic_cast<const DtVisualizerAttributeStringVector*>(attr);
         if (multiDefs)
         {
            const DtUnicode* modelDefinition = chooseRandomString(multiDefs->value());
            if(modelDefinition)
            {
               return *modelDefinition;
            }
         }
         else
         {            
            const DtVisualizerAttributeString* singleDef = dynamic_cast<const DtVisualizerAttributeString*>(attr);
            if (singleDef)
            {
               return singleDef->value();
            }
         }
      }
      return DtUnicode();
   }
   
   void DtCreateObjectMenuItem::on_triggered()
   {
//       DtEntityTypeMapper::const_iterator iter;
// 
//       {
//          DtReadSettingsLock<DtSharedSimulationSettings> settings(DtSharedSettingsManager::instance(myDe));
//          const DtEntityTypeMapper& mapper = settings->entityTypeMapper();
// 
//          do
//          {
//             iter = mapper.begin();
// 
//             int iIndex = myRandomNumberGenerator.generate(0, 400);
// 
//             while ((iIndex > -1) && (iter != mapper.end()))
//             {
//                ++iter;
//                --iIndex;
//             }
//          } while ((iter == mapper.end()) ||
//                   ((iter->first.kind() != 1) &&
//                   (iter->first.kind() != 3)));
//       }
//       
//       //! iter->second references an Element Definition.  Find the Correct modeldefinition for model set
//       // 0, given that.
//       int mode = myDe.driverManager().inputDriver().currentObserver()->observerMode();
//       int modelSet = DtObserverModeManager::instance(myDe).modelSet(mode);
//       
//       DtUnicode modelDefinition;
//       
//       const DtVisualDefinitionSet* cachedSet = 0;
//       {
//          DtReadSettingsLock<DtEntityElementDictionary> visualSetManager(DtSharedSettingsManager::instance(myDe));
//          cachedSet = visualSetManager->findVisualDefinitionSet(iter->second[0], 0);
//       }
// 
//       if ( cachedSet )
//       {
//          modelDefinition = modelDefFromVisualSet( *cachedSet );
//       }
//       else
//       {
//          DtVisualDefinitionSet defaultSet;
//          {
//             DtWriteSettingsLock<DtEntityElementDictionary> visualSetManager(DtSharedSettingsManager::instance(myDe));
//             defaultSet = visualSetManager->visualDefinitionSet(iter->second[0], 0);
//             modelDefinition = modelDefFromVisualSet( defaultSet );
//          }
//       }
// 
//       //! First, create the root kinematic state.  This is needed to be able to move and articulate the model
//       DtVisualDefinitionSet set;
// 
//       DtVisualDefinition kinState("DtKinStateVisualizer");
//       kinState.addVisualAttribute("rootobject", DtVisualAttributeBool(true));
//       kinState.addVisualAttribute("mandatory", DtVisualAttributeBool(true));
//       kinState.addVisualAttribute("type", DtVisualAttributeString("DtEntityKinStateVisualizer"));
//       kinState.addVisualAttribute("name", DtVisualAttributeString("Main Object"));
//       set.addVisualDefinition(kinState);
// 
//       //! Now, create the model and attach it to the kinematic state.  Set the model definition
//       //! to the random one selected from above
//       
//       //! If the kind is a lifeform, use the DI Guy model visualizer, else the articulated part model visualizer
// 
//       if (iter->first.kind() == 3)
//       {
//          DtVisualDefinition diGuy("DtModelVisualizer");
//          diGuy.addVisualAttribute("mandatory", DtVisualAttributeBool(true));
//          diGuy.addVisualAttribute("type", DtVisualAttributeString("DtEntityDIGuyStateVisualizer"));
//          diGuy.addVisualAttribute("parent", DtVisualAttributeString("Main Object"));
//          diGuy.addVisualAttribute("modeldefinition", DtVisualAttributeString(modelDefinition));
//          diGuy.addVisualAttribute("visualType", DtVisualAttributeString("main_model"));
//          set.addVisualDefinition(diGuy);
//       }
//       else
//       {
//          DtVisualDefinition articulated("DtModelVisualizer");
//          articulated.addVisualAttribute("mandatory", DtVisualAttributeBool(true));
//          articulated.addVisualAttribute("type", DtVisualAttributeString("DtEntityArticulatedStateModelVisualizer"));
//          articulated.addVisualAttribute("parent", DtVisualAttributeString("Main Object"));
//          articulated.addVisualAttribute("modeldefinition", DtVisualAttributeString(modelDefinition));
//          articulated.addVisualAttribute("visualType", DtVisualAttributeString("main_model"));
//          set.addVisualDefinition(articulated);
//       }
// 
//       //! Finally, attach the indicator and information item to the object
//       DtVisualDefinition indicator("DtIndicatorVisualizer");
//       indicator.addVisualAttribute("type", DtVisualAttributeString("DtExampleIndicatorVisualizer"));
//       indicator.addVisualAttribute("parent", DtVisualAttributeString("Main Object"));
//       indicator.addVisualAttribute("mandatory", DtVisualAttributeBool(true));
//       indicator.addVisualAttribute("modelDefinition", DtVisualAttributeString("entityInfo"));
//       indicator.addVisualAttribute("modelDefinitionSchema", DtVisualAttributeString("WidgetTheme"));
//       set.addVisualDefinition(indicator);
// 
//       //! Now, set a random location based on extent and altitiude at that extent
//       DtTerrain::TerrainPatches::const_iterator curIter = myDe.scene().terrain().terrainPatches().begin();
//       DtVector nw, ne, sw, se;
//       DtTerrainPatchObject* tso = (*curIter)->agent()->findObject();
//       if(tso != 0)
//       {
//          tso->getTerrainExtents(nw, ne, sw, se);
// 
//          //! Now that the set is defined, pass it to the entity facade for creation
//          DtEntityFacade* facade = new DtEntityFacade(myDe.agentManager(), modelSet);
// 
//          facade->visualize(set);
// 
//          int x = myRandomNumberGenerator.generate(sw.x(), ne.x()); 
//          int y = myRandomNumberGenerator.generate(sw.y(), ne.y()); 
// 
//          DtVector d(x, y, 0.);
// 
//          DtIntersector::DtIntersections intersections;
// 
//          DtCoordinateConverter* conv = myDe.sharedState().coordinateSystem().converter();
//          conv->setupTopoFrame( d );
//          DtVector up = conv->up( d );
//          DtIntersectorResult res;
//          
//          DtIntersectorManager::instance(myDe).modelSetIntersector(modelSet).findNearestIntersectionToPoint(
//             d.x(), d.y(), d.z(), up.x(), up.y(), up.z(), res, 
//             DtIntersector::SupportNodes );
// 
//          d.setZ(res.z);
// 
//          facade->setPosition(d);
//          facade->setVisible(true);
// 
//          //! Now, attach to this new object
// 
//          std::vector<DtUniqueID> objects;
//          objects.push_back(facade->uniqueID());
//          makVrv::DtObserver* currentObserver = myDe.driverManager().inputDriver().currentObserver();
//          currentObserver->setPrimaryAttachment(objects);
//       }
   }
}

DtExampleMenu.h

/******************************************************************************
** Copyright (c) 2008 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: DtExampleMenu.h,v $ $Revision: 1.1 $ $State: Exp $
******************************************************************************/


#pragma once
#include "exampleVisualDefinitionSetPlugin.h"
#include <vrvUtil/DtRandomNumberGenerator.h>
#include <vrvCoreQt/DtMenu.h> 
#include <vrvCoreQt/DtMenuItem.h>
#include <vrvUtil/DtUnicode.h>

class QAction;

namespace makVrv
{
   class DtVisualizerDefinitionSet;

   class DT_DLL_EXAMPLEVISUALDEFINITIONSETPLUGIN DtExampleMenu : public DtMenu
   { 
   public:

      DtExampleMenu(DtDe& de);

      virtual ~DtExampleMenu();

      virtual QMenu* createMenu(DtDe&, QWidget* parent);

   };

   class DT_DLL_EXAMPLEVISUALDEFINITIONSETPLUGIN DtCreateObjectMenuItem : 
      public DtMenuItem
   {
   public:
      DtCreateObjectMenuItem(DtDe& de);
      virtual ~DtCreateObjectMenuItem();

      virtual QAction* createAction( DtDe&, QWidget* parent );

      virtual void on_triggered();

      virtual void on_aboutToShow();

   protected:
   
      DtUnicode modelDefFromVisualSet( const DtVisualizerDefinitionSet& set );
      const DtUnicode* chooseRandomString(const std::vector<DtUnicode>& definitions);
   protected:
      DtDe& myDe;
      QAction* myAction;

      //The random number generator to pick model to display
      DtRandomNumberGenerator myRandomNumberGenerator;
   };
}