exampleViewControl

Table of Contents

• Overview
• Expected Result
• Example details
• Building the Example
• Running the Example
• Example Source Files
• MyLightScaleCommand.h
• MyLightScaleCommand.cxx
• MyAttachObserverCommand.h
• MyAttachObserverCommand.cxx
• MyViewControlDataTypes.h
• MyViewControlDataTypes.inl

Overview

Shows how to add a new view control to the VR-Vantage Control Toolkit.

Expected Result

We use exampleSendControl to demonstrate the view control message created in this example. Using exampleSendControl, you can observe the following behavior:

Before you enter 'W'

After you enter 'W'

Note: A 3D model was added to the scene to better illustrate the change in render settings. To do this, the startup scripts for this example loads the exampleDistributedObject plugin which, among other things, places a 3D model in the scene.

Example details

The VR-Vantage Control Toolkit lets you send DIS or HLA messages that can remotely control a VR-Vantage application. It has messages for most VR-Vantage display settings. This example shows how to add new control messages by adding a viewLightScale view control message, and a custom attach observer message.

VR-Vantage does not send view controls so in order to test the receipt of this new view control a new application will need to be created to send them. We show how to send view controls in exampleSendControl but also use this example to demonstrate the view control message created in this example.

Please review the comments in the files for details.

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

When using HLA1516e, it's important to configure the default connection using the RTI Assistant. In Windows, the RTI Assistant can be found under "MAK Technologies" from the Windows start menu. In Linux, the RTI Assistant can be started using the "./rtiAssitstant -N" script located in the RTI installed location bin folder. Using the RTI Assistant connection preferences tab, set the default connection to be "[machine name]'s predefined rtiexec loopback connection" rather than the default "Predefined lightweight loopback connection".

Example Source Files

• MyLightScaleCommand.cxx
• MyLightScaleCommand.h
• MyAttachObserverCommand.cxx
• MyAttachObserverCommand.h
• MyViewControlDataTypes.h
• MyViewControlDataTypes.inl

---

MyLightScaleCommand.h

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


#pragma once

#include "exampleViewControlPlugin.h"

#include <vrvCore/DtVrvCommand.h>
#include "MyViewControlDataTypes.h"

using namespace makVrv;

namespace MyViewControl
{
   class DT_DLL_EXAMPLEVIEWCONTROL MyLightScaleCommand : public DtVrvCommand
   {
   public: 
      MyLightScaleCommand();

      virtual ~MyLightScaleCommand();
      

      virtual bool diffuseLightScaleSet() const;

      virtual int diffuseLightScale() const;

      // effect of setting diffuseLightScaleSet() to true     
      virtual void setDiffuseLightScale( int scale );


      virtual bool ambientLightScaleSet() const;

      virtual int ambientLightScale() const;

      // effect of setting ambientLightScaleSet() to true
      virtual void setAmbientLightScale( int scale );


      virtual void execute(DtDe& de);

   protected:
      int myDiffuseLightScale;

      int myAmbientLightScale;
 
      bool myDiffuseLightScaleSet;
 
      bool myAmbientLightScaleSet;
   };

   class DT_DLL_EXAMPLEVIEWCONTROL MyLightScaleCommandCreator 
      : public DtVrvCommandCreator
   {
   public:
      MyLightScaleCommandCreator(GlobalIdConvertFunc func);

      virtual ~MyLightScaleCommandCreator();

      virtual DtVrvCommand* create(vrvControlToolkit::DtVrvControl_v1* control);
   };
}

MyLightScaleCommand.cxx

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


#include "MyLightScaleCommand.h"

#include <vrvCore/DtDe.h>
#include <vrvCore/DtDeSharedState.h>

using namespace makVrv;

namespace MyViewControl
{

   MyLightScaleCommand::MyLightScaleCommand()
      : DtVrvCommand()
      , myDiffuseLightScale(0)
      , myAmbientLightScale(0)
      , myDiffuseLightScaleSet(false)
      , myAmbientLightScaleSet(false)
   {
      myCommandType = (vrvControlToolkit::DtVrvControlTypeEnum) 
        MyControlToolkit::MyVrvControlTypeEnum::Control_LightScale;
   }

   MyLightScaleCommand::~MyLightScaleCommand()
   {
   }
      
   bool MyLightScaleCommand::diffuseLightScaleSet() const
   {
      return myDiffuseLightScaleSet;
   }

   int MyLightScaleCommand::diffuseLightScale() const
   {
      return myDiffuseLightScale;
   }

   void MyLightScaleCommand::setDiffuseLightScale( int scale )
   {
      myDiffuseLightScale = scale;
      myDiffuseLightScaleSet = true;
   }

   bool MyLightScaleCommand::ambientLightScaleSet() const
   {
      return myAmbientLightScaleSet;
   }

   int MyLightScaleCommand::ambientLightScale() const
   {
      return myAmbientLightScale;
   }

   void MyLightScaleCommand::setAmbientLightScale( int scale )
   {
      myAmbientLightScale = scale;
      myAmbientLightScaleSet = true;
   }
  
   void MyLightScaleCommand::execute(DtDe& de)
   {
      if ( diffuseLightScaleSet() )
      {
          de.sharedState().setLightingDiffuseScale(diffuseLightScale());
      }      
      if ( ambientLightScaleSet() )
      {
         de.sharedState().setLightingAmbientScale(ambientLightScale());
      }
   }

   MyLightScaleCommandCreator::MyLightScaleCommandCreator(GlobalIdConvertFunc func)
      : DtVrvCommandCreator(func)
   {
   }

   MyLightScaleCommandCreator::~MyLightScaleCommandCreator() 
   {
   }

   DtVrvCommand* MyLightScaleCommandCreator::create( 
      vrvControlToolkit::DtVrvControl_v1* control )
   {
      MyLightScaleCommand* retCmd = 0;
      if ( control->myVersion == 1 )
      {
         if( control->mySize == sizeof( MyControlToolkit::MyLightScale_v1 ) )
         {
            retCmd = new MyLightScaleCommand();
            MyControlToolkit::MyLightScale_v1* lightScaleControl = 
               (MyControlToolkit::MyLightScale_v1*) control;

            if ( lightScaleControl->myValuesSetFlags & 
               MyControlToolkit::MyLightScale_v1::DiffuseLightScaleSet )
            {
               retCmd->setDiffuseLightScale( lightScaleControl->myDiffuseLightScale );
            }
            if ( lightScaleControl->myValuesSetFlags & 
               MyControlToolkit::MyLightScale_v1::AmbientLightScaleSet )
            {
               retCmd->setAmbientLightScale( lightScaleControl->myAmbientLightScale);
            }
         }
      }

      return retCmd;
   }

}

MyAttachObserverCommand.h

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


#pragma once

#include "exampleViewControlPlugin.h"

#include <vrvCore/DtVrvCommand.h>
#include "MyViewControlDataTypes.h"

using namespace makVrv;

namespace MyViewControl
{
   class DT_DLL_EXAMPLEVIEWCONTROL MyAttachObserverCommand : public DtVrvCommand
   {
   public:
      MyAttachObserverCommand();

      virtual ~MyAttachObserverCommand();

      virtual const DtUniqueID& entityId();
      virtual void setEntityId( const DtUniqueID& entityId );

      virtual const std::string& sensorName();
      virtual void setSensorName( const std::string& sensorName );

      virtual const std::string& observerName();
      virtual void setObserverName( const std::string& observerName );

      virtual bool createOverlay() const;
      virtual void setCreateOverlay( bool );

      virtual void execute( DtDe& de );

   protected:
      DtUniqueID myEntityId;
      std::string mySensorName;
      std::string myObserverName;
      bool myCreateOverlay;
   };

   class DT_DLL_EXAMPLEVIEWCONTROL MyAttachObserverCommandCreator
      : public DtVrvCommandCreator
   {
   public:
      MyAttachObserverCommandCreator( GlobalIdConvertFunc func );

      virtual ~MyAttachObserverCommandCreator();

      virtual DtVrvCommand* create( vrvControlToolkit::DtVrvControl_v1* control );
   };
}

MyAttachObserverCommand.cxx

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


#include "MyAttachObserverCommand.h"

#include <vrvCore/DtDe.h>
#include <vrvCore/DtDeSharedState.h>
#include <vrvCore/DtVrvCommand.h>

#include <vrvCore/DtDriverManager.h>
#include <vrvCore/DtInputDriver.h>
#include <vrvCore/DtObserver.h>
#include <vrvCore/DtObserverObjectAgent.hpp>
#include <vrvCore/DtSensorFieldOfViewManager.h>
#include <vrvCore/DtModelSemanticsMapper.h>
#include <vrvCore/DtObserverSettingsManager.h>

#include <vrvCore/DtWindowManager.h>
#include <vrvCore/DtChannelManager.h>
#include <vrvCore/DtDisplay.h>
#include <vrvCore/DtWindow.h>
#include <vrvCore/DtChannel.h>

using namespace makVrv;

namespace MyViewControl
{

   MyAttachObserverCommand::MyAttachObserverCommand()
      : DtVrvCommand()
      , myCreateOverlay( true )
      , myEntityId( DtUniqueID( 0 ) )
      , mySensorName( "" )
      , myObserverName( "" )
   {
      myCommandType = (vrvControlToolkit::DtVrvControlTypeEnum)
         MyControlToolkit::MyVrvControlTypeEnum::AttachObserverToSensor;
   }

   MyAttachObserverCommand::~MyAttachObserverCommand()
   {
   }

   const DtUniqueID& MyAttachObserverCommand::entityId()
   {
      return myEntityId;
   }

   void MyAttachObserverCommand::setEntityId( const DtUniqueID& u )
   {
      myEntityId = u;
   }

   const std::string& MyAttachObserverCommand::sensorName()
   {
      return mySensorName;
   }

   void MyAttachObserverCommand::setSensorName( const std::string& u )
   {
      mySensorName = u;
   }

   const std::string& MyAttachObserverCommand::observerName()
   {
      return myObserverName;
   }

   void MyAttachObserverCommand::setObserverName( const std::string& u )
   {
      myObserverName = u;
   }

   bool MyAttachObserverCommand::createOverlay() const
   {
      return myCreateOverlay;
   }

   void MyAttachObserverCommand::setCreateOverlay( bool b )
   {
      myCreateOverlay = b;
   }


   static makVrv::DtUniqueID oldId = 0;
   static makVrv::DtUniqueID oldSensorId = 0;

   void MyAttachObserverCommand::execute( DtDe& de )
   {
      if( myEntityId == 0 )
      {
         DtWarn << "MyAttachObserverCommand element ID == 0" << std::endl;
         return;
      }

      if( mySensorName == "" )
      {
         DtWarn << "MyAttachObserverCommand mySensorName string is empty" << std::endl;
         return;
      }

      std::string obsName = myObserverName == "" ? "Observer 1" : myObserverName;

      DtObserver* observer = de.driverManager().inputDriver().findObserverByName(
         obsName );

      if( observer )
      {
         std::vector<DtUniqueID> idVector;
         idVector.push_back( myEntityId );
         observer->setAttachType( DtObserverObject::AttachType::AttachTypeMimic );
         observer->setPrimaryAttachment( idVector );
         // This comes from VRF
         const DtModelSemanticsMapper::Parts::Id* id = DtModelSemanticsMapper::instance( de ).findPartId( "gimbaled_sensor_elevation_1" );
         observer->setPartAttachment( *id );
         observer->setHideModelOnAttach( true );
      }

      DtDisplay* display = de.display();
      if( display )
      {
         for( auto& window : display->windowManager().windows() )
         {
            for( auto& channel : window->channelManager().channels() )
            {
               if( channel.second->observerName() == obsName )
               {
                  DtChannelConfiguration* newConfig = const_cast<DtChannelConfiguration*>(& channel.second->configuration());
                  if( newConfig )
                  {
                     newConfig->removeKeyword( "showCockpits" );
                  }
               }
            }
         }
      }

      if( myCreateOverlay )
      {
         DtSensorFieldOfViewManager& fieldOfViewMgr = DtSensorFieldOfViewManager::instance( de );

         const DtSensorFieldOfViewManager::SensorFieldOfViewDataMap* fieldsOfView = fieldOfViewMgr.fieldsOfViewForEntity( myEntityId );

         if( oldId != 0 && oldSensorId != 0 )
         {
            fieldOfViewMgr.removeSensorOverlay( oldId, oldSensorId );

         }

         if( fieldsOfView )
         {
            for( auto& fieldOfView : *fieldsOfView )
            {
               if( fieldOfView.second.sensorId() == mySensorName && !fieldOfViewMgr.hasSensorObserver( myEntityId, fieldOfView.first ) )
               {
                  oldId = myEntityId;
                  oldSensorId = fieldOfView.first;
                  fieldOfViewMgr.addSensorObserver( obsName, myEntityId, fieldOfView.first, false );

               }
            }
         }
      }
   }

   MyAttachObserverCommandCreator::MyAttachObserverCommandCreator( GlobalIdConvertFunc func )
      : DtVrvCommandCreator( func )
   {
   }

   MyAttachObserverCommandCreator::~MyAttachObserverCommandCreator()
   {
   }

   DtVrvCommand* MyAttachObserverCommandCreator::create(
      vrvControlToolkit::DtVrvControl_v1* control )
   {
      MyAttachObserverCommand* retCmd = 0;
      if( control->myVersion == 1 )
      {
         if( control->mySize == sizeof( MyControlToolkit::MyAttachObserverToSensor_v1 ) )
         {
            MyControlToolkit::MyAttachObserverToSensor_v1* attachControl =
               (MyControlToolkit::MyAttachObserverToSensor_v1*) control;
            retCmd = new MyAttachObserverCommand();

            retCmd->setEntityId( myConvertGlobablIdFunc( attachControl->myEntity ) );
            retCmd->setCreateOverlay( attachControl->myCreateOverlay );
            retCmd->setSensorName( attachControl->mySensorName );
            retCmd->setObserverName( attachControl->myObserverName );
         }
      }

      return retCmd;
   }

}

MyViewControlDataTypes.h

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


#pragma once

#include <vrvControl/vrvControlToolkitDataTypes.h>

namespace MyControlToolkit
{
   // Declare the enumerants to use for you custom view control messages.  This
   // could be added directly to vrvControlToolkitDataTypes.h, but then you 
   // would need to re-merge with each new release.  It makes more sense to 
   // manage your own packets this way.
   enum class MyVrvControlTypeEnum : unsigned int
   {
      Control_LightScale = static_cast<unsigned int>(vrvControlToolkit::DtVrvControlTypeEnum::Control_UserStart),
      AttachObserverToSensor
   };

   // Declare the packet(s) that will contain your view control message(s). 
   // This message will set a scale factor for the diffuse and/or ambient light
   // values in the scene
   struct MyLightScale_v1  : public vrvControlToolkit::DtVrvControl_v1
   {
      inline MyLightScale_v1();
      inline ~MyLightScale_v1();

     // Similar to VR-Link net types, the The vrvControlToolkit types will
     // manage byte-swapping if needed.
      vrvControlToolkit::DtUInt32 myDiffuseLightScale; // (0 - ??)
      vrvControlToolkit::DtUInt32 myAmbientLightScale; // (0 - ??)

     // This enumeration describes bit values set in the myValuesSetFlags
     // member to indicate which of the messages members should be processed
      enum LightScaleSettingsUsed
      {
         DiffuseLightScaleSet = 1,
         AmbientLightScaleSet = 2,
      };

     // Bit-encoded integer that indicates which values are set
      vrvControlToolkit::DtUInt8 myValuesSetFlags;
   };

   struct MyAttachObserverToSensor_v1 : public vrvControlToolkit::DtVrvControl_v1
   {
      inline MyAttachObserverToSensor_v1();
      inline ~MyAttachObserverToSensor_v1();

      vrvControlToolkit::DtInt8 myEntity[vrvControlToolkit::DtVrvControlNameSize];

      vrvControlToolkit::DtInt8 mySensorName[vrvControlToolkit::DtVrvControlNameSize];

      vrvControlToolkit::DtInt8 myObserverName[vrvControlToolkit::DtVrvControlNameSize];

      bool myCreateOverlay;
   };
}

#include "MyViewControlDataTypes.inl"

MyViewControlDataTypes.inl

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


#pragma once

#include "MyViewControlDataTypes.h"

namespace MyControlToolkit
{

   //----------------------Light Scale Command ----------------------
   MyLightScale_v1::MyLightScale_v1()
      : vrvControlToolkit::DtVrvControl_v1()
   {
      // Base struct setup
      myType = (vrvControlToolkit::DtVrvControlTypeEnum)MyVrvControlTypeEnum::Control_LightScale;
      myVersion = 1;
      mySize = sizeof(MyLightScale_v1);

      // Initial Values
      myDiffuseLightScale = 0;
      myAmbientLightScale = 0;
      myValuesSetFlags = 0;
   }

   MyLightScale_v1::~MyLightScale_v1()
   {
   }

   //----------------------AttachObserverToSensor ----------------------
   MyAttachObserverToSensor_v1::MyAttachObserverToSensor_v1()
      : vrvControlToolkit::DtVrvControl_v1()
   {
      // Base struct setup
      myType = (vrvControlToolkit::DtVrvControlTypeEnum) MyVrvControlTypeEnum::AttachObserverToSensor;
      myVersion = 1;
      mySize = sizeof( MyAttachObserverToSensor_v1 );

      memset( myEntity, 0, sizeof( vrvControlToolkit::DtInt8[vrvControlToolkit::DtVrvControlNameSize] ) );
      memset( mySensorName, 0, sizeof( vrvControlToolkit::DtInt8[vrvControlToolkit::DtVrvControlNameSize] ) );
      memset( myObserverName, 0, sizeof( vrvControlToolkit::DtInt8[vrvControlToolkit::DtVrvControlNameSize] ) );
      myCreateOverlay = true;
   }

   MyAttachObserverToSensor_v1::~MyAttachObserverToSensor_v1()
   {
   }
}

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