exampleDrawObjects

Table of Contents

• Overview
• Expected Result
• Example details
• Building the Example
• Running the Example
• Example Source Files
• drawObjects.cxx

Overview

This example demonstrates how to use the vrvControlToolkit to draw objects remotely on an instance of VR-Vantage.

Expected Result

Draw Object Result

Example details

The example will run through a series of 3D objects (sphere/cube/cylinder/line), then move on to 2D objects (text/line/circle/triangle/square). Please note that in order to see the 3D objects, you need to load Makland.mtf, and use the saved view "exampleDrawObjectsMaklandView.osrx".

Building the Example

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

Running the Example

This example is an application. First open Vantage, load MakLand terrain than from the "Observer Views" panel click on "import and append views" and select "exampleDrawObjectsMaklandView.osrx" then click on "remoteGraphicsMaklandView", then connect with the <protocol> you will use the example with. Run ./bin64/exampleDrawObjects<protocol>.exe (on Windows) or ./bin64/exampleDrawObjects<protocol> (on Linux). Upon running this example, any running instances of VR-Vantage that are connected to the appropriate connection (DIS/HLA13/HLA1516) will display the objects rendered by the example.

For more information about running examples, please see Running Applications and Examples.

Example Source Files

• drawObjects.cxx

---

drawObjects.cxx

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


#include <vl/exerciseConn.h>
#include <vl/exerciseConnInitializer.h>
#include <vlutil/vlProcessControl.h>

#include <matrix/utmCoord.h>
#include <matrix/vlTaitBryan.h>

#include <vl/dataInteraction.h>

#include <vrvControl/DtVrlinkDataInterMarshaller.h>
#include <vrvControl/vrvControlToolkitDataTypes.h>

#include <vrvDrawControl/DtCuboidObject.h>
#include <vrvDrawControl/DtEllipsoidObject.h>
#include <vrvDrawControl/DtText3DObject.h>
#include <vrvDrawControl/DtText2DObject.h>
#include <vrvDrawControl/DtLine3DObject.h>
#include <vrvDrawControl/DtArea3DObject.h>
#include <vrvDrawControl/DtCylinderObject.h>
#include <vrvDrawControl/DtRectangleObject.h>
#include <vrvDrawControl/DtTriangle2DObject.h>
#include <vrvDrawControl/DtEllipseObject.h>
#include <vrvDrawControl/DtLine2DObject.h>
#include <vrvDrawControl/DtAttributeGroupObject.h>
#include <vrvDrawControl/DtAttributeGroupTemplateObject.h>

#include <matrix/topoCoord.h>

#include <stdio.h>
#include <vlutil/vlKeyboard.h>


#ifdef DtDIS
#   include <vrvDis/vrvDis.h>
#   define DT_PROTOCOL_NAMESPACE vrvDis
#else
#   ifdef DtHLA_1516_EVOLVED
#      include <vrvHla1516e/vrvHla1516e.h>
#      define DT_PROTOCOL_NAMESPACE vrvHla1516e
#   else
#      ifdef DtHLA_1516
#         include <vrvHla1516/vrvHla1516.h>
#         define DT_PROTOCOL_NAMESPACE vrvHla1516
#      else
#         ifdef DtHLA
#            include <vrvHla13/vrvHla13.h>
#            define DT_PROTOCOL_NAMESPACE vrvHla13 
#            define DL_DLL_IGCONVRLINK DT_DLL_VRVHLA13 

#         else
#            error "Protocol not specified or unsupported."
#         endif
#      endif
#   endif
#endif

#if DtHLA
#include <vrvVrl/epFomMap.h>
#endif

using namespace vrvControlToolkit;

DtExerciseConn* exConn;
std::vector<DtDrawControlObject*> myObjects;
DtText2DObject* myText = 0;
DtVrlinkDataInterMarshaller<DtDataInteraction> myCommandMarshaller;

int id = 0;

// Updates the objects in our objects list.
void updateObjects(double time = 0.0)
{
   if (time > 0.0)
   {
      DtTime tickTime = exConn->clock()->elapsedRealTime();
      while (exConn->clock()->simTime() <= tickTime + time)
      {
         exConn->drainInput();
         for (unsigned int i = 0; i < myObjects.size(); ++i)
         {
            myObjects[i]->update();
         }
         exConn->clock()->setSimTime(exConn->clock()->elapsedRealTime());
         DtSleep(0.1);
      }
   }
   else
   {
      exConn->drainInput();
      for (unsigned int i = 0; i < myObjects.size(); ++i)
      {
         myObjects[i]->update();
      }
      exConn->clock()->setSimTime(exConn->clock()->elapsedRealTime());
   }
}

// Prints a messages in 2D text to the screen.
void setMsg(char *msg)
{
    DtNetU8 ucolor[4] = {255, 255, 255, 255};
    double pos1[2];
 
    pos1[0] = (-40 / 200.) + .5;
    pos1[1] = (70 / 200.) + .5;

    if (!myText)
    {
       myText = new DtText2DObject(exConn, 300, "",
          DtVdcVector2D(pos1[0], pos1[1]));
       exConn->drainInput();
       myText->setFlashing(0);
       DtVdcColor colorToSet(ucolor[0], ucolor[1], ucolor[2], ucolor[3]);
       myText->setColor(colorToSet);
       myObjects.push_back(myText);
    }
    myText->setFont("$(SHARED_DATA_DIR)/Fonts/FreeSans.otf", 14);
    myText->setText(msg);
    myText->update(); 

   // Process any incoming messages.
   exConn->drainInput();
   DtSleep(0.1);
   
}

// Shows the specified set.
void showSet(const DtString& setName)
{
   DtRemoteGraphicSet_v1 showSetCommand;
   sprintf(showSetCommand.mySetName, "%s", setName.c_str());
   showSetCommand.myState = true;

   DtDataInteraction dataInter;
   myCommandMarshaller.encode(&showSetCommand, &dataInter);
   exConn->sendStamped(dataInter);
}

// Hides the specified set.
void hideSet(const DtString& setName)
{
   DtRemoteGraphicSet_v1 showSetCommand;
   sprintf(showSetCommand.mySetName, "%s", setName.c_str());
   showSetCommand.myState = false;

   DtDataInteraction dataInter;
   myCommandMarshaller.encode(&showSetCommand, &dataInter);
   exConn->sendStamped(dataInter);
}

// Runs the 2D demo
void demo2d()
{
   id = 100;

   showSet("2D Objects");
   setMsg("2D Demo, Text....");
   showSet("2D Objects::Text");

   int i;
   unsigned pattern;
   double pos1[2], pos2[2];
   DtVdcColor ucolor(DtVdcColor::DtVdcWhite);
   double scale[3];
   double rot;

   pos1[0] = .1;
   pos1[1] = .3;
   ucolor[0] = 255;ucolor[1] = 255; ucolor[2] = 255; ucolor[3] = 255;
   char texts[3][256] ={"2DText1", "2DText2", "2DText with spaces 3"};
   for (i = 0; i < 3; i++)
   {
      DtText2DObject* text2D = new DtText2DObject(exConn, id++, 
         texts[i], DtVdcVector2D(pos1[0], pos1[1]));
      text2D->setColor(ucolor);
      text2D->setFlashing(((i % 2) != 0));
      text2D->setRemoteGraphicSet("2D Objects::Text");
      myObjects.push_back(text2D);

      updateObjects();

      ucolor[i] -= 50;
      pos1[1] += 0.2;
      DtSleep(1);
   }

   DtSleep(2);
   hideSet("2D Objects::Text");

   setMsg("2D Demo, Squares....");
   showSet("2D Objects::Squares");

   pos1[0] = .3;
   pos1[1] = .2;
   rot = 0;
   scale[0] = 0.15;
   scale[1] = 0.15;
   pattern = 0xffffffff;
   ucolor[0] = 255;ucolor[1] = 255; ucolor[2] = 255; ucolor[3] = 255;

   for (i = 0; i < 4; i++)
   {
      DtRectangleObject* square = new DtRectangleObject(exConn, id++, 
         DtVdcVector2D(pos1[0], pos1[1]), 
         DtVdcVector2D(scale[0] / 2, scale[1] / 2));

      square->setColor(ucolor);
      square->setRotation(rot);
      square->setFlashing((((i+1)%3) == 0));
      square->setFill((((i+1)%3) != 0));
      square->setPattern(pattern);
      square->setRemoteGraphicSet("2D Objects::Squares");
      myObjects.push_back(square);

      updateObjects();
      pattern -= 678;
      ucolor[i%3] -= 120;
      pos1[1] += .15;
      rot += DtDeg2Rad(35);
      scale[i%2] += 0.05 *(i+1);
      DtSleep(1);
   }

   DtSleep(2);
   hideSet("2D Objects::Squares");

   setMsg("2D Demo, Circles....");
   showSet("2D Objects::Circles");

   pos1[0] = 0.5;
   pos1[1] = 0.1;
   rot = 0;
   scale[0] = 0.15;
   scale[1] = 0.15;
   pattern = 0xbbbbbbbb;
   ucolor[0] = 255;ucolor[1] = 255; ucolor[2] = 255; ucolor[3] = 255;

   for (i = 0; i < 4; i++)
   {
      DtEllipseObject* circle = new DtEllipseObject(exConn, id++, 
         DtVdcVector2D(pos1[0], pos1[1]), 
         DtVdcVector2D(scale[0] / 2, scale[1] / 2));

      circle->setFlashing((((i+1)%3) == 0));
      circle->setColor(ucolor);
      circle->setRotation(rot);
      circle->setFill((((i+1)%3) != 0));
      circle->setPattern(pattern);
      circle->setRemoteGraphicSet("2D Objects::Circles");
      myObjects.push_back(circle);

      updateObjects();

      pattern -= 678;
      ucolor[i%3] -= 80;
      pos1[1] += 0.2;
      rot += DtDeg2Rad(55);
      scale[i%2] += 0.05 *(i+1);
      DtSleep(1);
   }

   DtSleep(2);

   hideSet("2D Objects::Circles");

   setMsg("2D Demo, Triangles....");
   showSet("2D Objects::Triangles");

   pos1[0] = 0.7;
   pos1[1] = 0.2;
   rot = 0;
   scale[0] = 0.05;
   scale[1] = 0.05;
   pattern = 0xbbbbbbbb;
   ucolor[0] = 255;ucolor[1] = 255; ucolor[2] = 255; ucolor[3] = 255;
   DtVector points[3];
   points[0] = DtVector(0, 0, .5);
   points[1] = DtVector(1, 0, .5);
   points[2] = DtVector(.5, 1, .5);

   for (i = 0; i < 4; i++)
   {
      DtTriangle2DObject* triangle = new DtTriangle2DObject(exConn, id++,
         DtVdcVector2D(points[0].x(), points[0].y()),
         DtVdcVector2D(points[1].x(), points[1].y()),
         DtVdcVector2D(points[2].x(), points[2].y()));

      triangle->setOffset(DtVdcVector2D(pos1[0], pos1[1]));
      triangle->setFlashing((((i+1)%3) == 0));
      triangle->setColor(ucolor);
      triangle->setRotation(rot);
      triangle->setScale(DtVdcVector2D(scale[0], scale[1]));
      triangle->setFill((((i+1)%3) != 0));
      triangle->setPattern(pattern);
      triangle->setRemoteGraphicSet("2D Objects::Triangles");
      myObjects.push_back(triangle);

      updateObjects();

      pattern -= 678;
      ucolor[i%3] -= 80;
      pos1[1] += 0.2;
      rot += DtDeg2Rad(55);
      scale[i%2] += 0.05 *(i+1);
      DtSleep(1);
   }

   DtSleep(2);
   hideSet("2D Objects::Triangles");

   setMsg("2D Demo, Lines....");
   showSet("2D Objects::Lines");

   pos2[0] = 0.75;
   pos2[1] = 0.2;
   pos1[0] = 0.25;
   pos1[1] = 0.5;
   rot = 0;
   scale[0] = 0.05;
   scale[1] = 0.05;
   pattern = 0xffffffff;
   ucolor[0] = 255;ucolor[1] = 255; ucolor[2] = 80; ucolor[3] = 255;

   int thick = 1;
   for (i = 0; i < 4; i++)
   {
      DtLine2DObject* line = new DtLine2DObject(exConn, id++, 
         DtVdcVector2D(pos1[0], pos1[1]),
         DtVdcVector2D(pos2[0], pos2[1]));
      line->setFlashing((((i+1)%3) == 0));
      line->setArrowStyle((DtVdcLineSegment::DtVdcSegmentArrowStyle)(DtVdcLineSegment::DtVdcSegmentArrowStyleNoArrow + i));
      line->setLineStyle((DtVdcLineSegment::DtVdcSegmentStyle)(DtVdcLineSegment::DtVdcSegmentStyleStraight +
         (((i+2)%3) == 0) * DtVdcLineSegment::DtVdcSegmentStyleLightning));
      line->setThickness(thick);
      line->setColor(ucolor);
      line->setPattern(pattern);
      line->setRemoteGraphicSet("2D Objects::Lines");
      myObjects.push_back(line);
      updateObjects();

      thick += 1;
      pattern -= 678;
      ucolor[i%3] -= 80;
      pos1[1] += .075;
      pos2[1] += .075;
      DtSleep(1);
   }

   DtSleep(2);
   hideSet("2D Objects::Lines");

   pattern = 0xffffffff;
   setMsg("2D Demo, Segmented Line....");   
   showSet("2D Objects::Segmented Lines");

   pos2[0] = 0.9;
   pos2[1] = 0.1;
   pos1[0] = 0.1;
   pos1[1] = 0.9;


   DtLine2DObject* segLine = new DtLine2DObject(exConn, id++, 
      DtVdcVector2D(pos1[0], pos1[1]),
      DtVdcVector2D(pos2[0], pos2[1]),
      4);
   segLine->setFlashing(0);
   segLine->setRemoteGraphicSet("2D Objects::Segmented Lines");

   thick = 1;
   ucolor[0] = 255;ucolor[1] = 255; ucolor[2] = 255; ucolor[3] = 255;
   for (i = 0; i < 4; i++)
   {
      segLine->setColor(ucolor, i);
      segLine->setPattern(pattern, i);
      segLine->setLineStyle((DtVdcLineSegment::DtVdcSegmentStyle)
         (DtVdcLineSegment::DtVdcSegmentStyleStraight + 
         (((i+2)%3) == 0) * DtVdcLineSegment::DtVdcSegmentStyleLightning), i);
      segLine->setArrowStyle((DtVdcLineSegment::DtVdcSegmentArrowStyle)(DtVdcLineSegment::DtVdcSegmentArrowStyleNoArrow + i), i);
      segLine->setThickness(thick, i);
      segLine->setPercentage(.25, i);
      pattern -= 0x11111111;
      ucolor[i%3] -= 100;
      thick += 2;
   }
   myObjects.push_back(segLine);
   updateObjects(2.0);

   setMsg("2D Demo, Changing Segmented Line....");

   int dt = 25;
   int inc = -1;
   for(int j = 0; j < 200; j++)
   {
      segLine->setPercentage((dt * 0.01), 0);
      for (i = 1; i < 3; i++)
      {
         segLine->setPercentage(0.25, i);
      }
      segLine->setPercentage((50 - dt) * 0.01, 3);

      dt += inc;
      if (dt == 25 || dt == 1)
         inc *= -1;

      updateObjects();
      DtSleep(0.1);
   }

   DtSleep(2);
   showSet("2D Objects::Text");
   showSet("2D Objects::Squares");
   showSet("2D Objects::Circles");
   showSet("2D Objects::Triangles");
   showSet("2D Objects::Lines");
   DtSleep(3);
   hideSet("2D Objects");
}

void demo3d()
{
   int i = 0;
   id = 1000;

   showSet("3D Objects");
   
   setMsg("Area...");
   showSet("3D Objects::Areas");

   unsigned ar1 = id++;
   std::vector<DtVector> vertices;
   vertices.push_back(DtVector(3140604, 5441190, 1101666));
   vertices.push_back(DtVector(3140317, 5440732, 1101132));
   vertices.push_back(DtVector(3140185, 5440580, 1101789));
   DtArea3DObject* ar = new DtArea3DObject(exConn, ar1, vertices);

   ar->setFlashing(false);
   ar->setColor(DtVdcColor(255, 255, 0, 100));
   ar->setRemoteGraphicSet("3D Objects::Areas");
   myObjects.push_back(ar);
   ar->setFlashing(true);
   updateObjects(1.0);
   DtSleep(5);

   hideSet("3D Objects::Areas");
   
   setMsg("Sphere...");
   showSet("3D Objects::Ellipsoids");
   
   unsigned sph1 = id++;
   DtEllipsoidObject* sphere = new DtEllipsoidObject(exConn, sph1, 
      DtVdc3DAttachPoint(DtVector(3140149, 5440872, 1101333)),
      DtVector(20, 20, 20));
   DtVdcColor clsp1(0, 255 ,0, 100);
   sphere->setFlashing(false);
   sphere->setColor(clsp1);
   sphere->setRemoteGraphicSet("3D Objects::Ellipsoids");
   myObjects.push_back(sphere);

   updateObjects(2.0);

   setMsg("Scaling sphere...");
   int scales[3];
   scales[0] = 20;
   scales[1] = 20;
   scales[2] = 20;
   int inc = 0;
   inc = 0;
   int clplus = 5;
   for (i = 0; inc < 3; i++)
   {
      scales[inc] += 4;
      clsp1[2] += clplus;
      sphere->setDiameters(DtVector(scales[0], scales[1], scales[2]));
      sphere->setColor(clsp1);

      updateObjects();

      if (scales[inc] > 60)
         inc++;
      DtSleep(0.1);
   }

   setMsg("Rotating sphere...");
   inc = 0;
   scales[0] = 10;
   scales[1] = 10;
   scales[2] = 10;
   for (i = 0; inc < 3; i++)
   {
      scales[inc] += 5;
      clsp1[2] += clplus;
      if (clsp1[2] == 250 || clsp1[2] == 50)
         clplus *= -1;
      sphere->setRotation(DtTaitBryan(DtDeg2Rad(scales[0]), DtDeg2Rad(scales[1]), DtDeg2Rad(scales[2])));
      sphere->setColor(clsp1);
      updateObjects();
      if (scales[inc] > 60)
         inc++;
      DtSleep(0.1);
   }

   hideSet("3D Objects::Ellipsoids");

   setMsg("Cube...");
   showSet("3D Objects::Cuboids");

   unsigned cubeId = id++;
   DtVdcColor clsp3(0, 0, 255, 100);
   DtCuboidObject* cube = new DtCuboidObject(exConn, cubeId, 
      DtVdc3DAttachPoint(sphere->globalId()), 10, 10, 10);
   cube->setColor(clsp3);
   cube->setRemoteGraphicSet("3D Objects::Cuboids");

   myObjects.push_back(cube);
   updateObjects(2.0);

   setMsg("Scaling cube...");
   scales[0] = 10;
   scales[1] = 10;
   scales[2] = 10;
   inc = 0;
   clplus = 5;
   for (i = 0; inc < 3; i++)
   {
      scales[inc] += 4;
      clsp1[3] += clplus;
      if (clsp1[3] == 250 || clsp1[3] == 50)
         clplus *= -1;
      cube->setLength(scales[0]);
      cube->setWidth(scales[1]);
      cube->setHeight(scales[2]);
      cube->setColor(clsp1);

      updateObjects();

      if (scales[inc] > 60)
         inc++;
      DtSleep(0.1);
   }

   setMsg("Rotating cube...");
   inc = 0;
   scales[0] = 10;
   scales[1] = 10;
   scales[2] = 10;
   for (i = 0; inc < 3; i++)
   {
      scales[inc] += 5;
      clsp1[2] += clplus;
      if (clsp1[2] == 250 || clsp1[2] == 50)
         clplus *= -1;
      cube->setRotation(DtTaitBryan(DtDeg2Rad(scales[0]), DtDeg2Rad(scales[1]), DtDeg2Rad(scales[2])));
      cube->setColor(clsp1);
      
      updateObjects();

      if (scales[inc] > 60)
         inc++;
      DtSleep(0.1);
   }

   cube->setOffset(DtVector32(150, 0, 0));

   updateObjects();

   hideSet("3D Objects::Cuboids");

   setMsg("Cylinder...");
   showSet("3D Objects::Cylinders");

   int cyl1 = id++;
   DtCylinderObject* cylinder = new DtCylinderObject(exConn, cyl1, 
      DtVdc3DAttachPoint(sphere->globalId()), 20, DtVdcVector2D(4, 4));
   cylinder->setFlashing(false);
   DtVdcColor clrcyl1(255, 0, 255, 60);
   cylinder->setColor(clrcyl1);
   cylinder->setRotation(DtTaitBryan(0,0,0));
   cylinder->setRemoteGraphicSet("3D Objects::Cylinders");

   myObjects.push_back(cylinder);

   updateObjects(2.0);

   setMsg("Scaling cylinder...");
   scales[0] = 20;
   scales[1] = 4;
   scales[2] = 4;
   inc = 0;
   clplus = 5;
   int size = 60;
   for (i = 0; inc < 3; i++)
   {
      scales[inc] += 4;
      clsp1[3] += clplus;
      if (clsp1[3] == 250 || clsp1[3] == 50)
         clplus *= -1;
      cylinder->setLength(scales[0]);
      cylinder->setDiameters(DtVdcVector2D(scales[1], scales[2]));
      cylinder->setColor(clsp1);

      updateObjects();

      if (scales[inc] > size)
      {
         inc++;
         size = 15;
      }
      DtSleep(0.1);
   }

   setMsg("Rotating cylinder...");
   inc = 0;
   scales[0] = 10;
   scales[1] = 10;
   scales[2] = 10;
   for (i = 0; inc < 3; i++)
   {
      scales[inc] += 5;
      clsp1[2] += clplus;
      if (clsp1[2] == 250 || clsp1[2] == 50)
         clplus *= -1;
      cylinder->setRotation(DtTaitBryan(DtDeg2Rad(scales[0]), DtDeg2Rad(scales[1]), DtDeg2Rad(scales[2])));
      cylinder->setColor(clsp1);

      updateObjects();

      if (scales[inc] > 60)
         inc++;
      DtSleep(0.1);
   }

   cylinder->setRotation(DtTaitBryan(0,0,0));
   // X is the length, YZ are the radius. Because we are linking between two spheres
   // the length is omited
   cylinder->setLength(120);
   cylinder->setDiameters(DtVdcVector2D(10, 10));

   updateObjects();

   setMsg("3D texts");
   showSet("3D Objects::Text");

   DtText3DObject* text = new DtText3DObject(exConn, id++, "Text One",
      DtVdc3DAttachPoint(cylinder->globalId()));
   DtVdcColor textcolor(255, 255, 0, 255);
   text->setFlashing(false);
   text->setColor(textcolor);
   text->setOffset(DtVector32(0, 15, 0));
   text->setRemoteGraphicSet("3D Objects::Text");
   myObjects.push_back(text);

   updateObjects(2.0);

   DtText3DObject* text2 = new DtText3DObject(exConn, id++, "FLASHING TEXT",
      DtVdc3DAttachPoint(cylinder->globalId()));
   text2->setColor(textcolor);
   text2->setFlashing(true);

   text2->setOffset(DtVector32(45, 0, 0));
   text2->setRemoteGraphicSet("3D Objects::Text");
   myObjects.push_back(text2);

   updateObjects(2.0); 

   DtSleep(4);

   hideSet("3D Objects::Cylinders");
   hideSet("3D Objects::Text");

   setMsg("3D lines");
   showSet("3D Objects::Lines");

   int line1 = id++;
   DtLine3DObject* line = new DtLine3DObject(exConn, line1, 
      DtVdc3DAttachPoint(cylinder->globalId()),
      DtVdc3DAttachPoint(cube->globalId()));

   DtVdcColor linecolor1(255 , 255, 50, 255);
   line->setFlashing(false);
   line->setColor(linecolor1);
   line->setPattern(0xffffffff);
   line->setLineStyle(DtVdcLineSegment::DtVdcSegmentStyleLightning);
   line->setArrowStyle(DtVdcLineSegment::DtVdcSegmentArrowStyleArrowDouble);
   line->setThickness(3);
   line->setOffset(DtVector32(0,0,50));
   line->setRemoteGraphicSet("3D Objects::Lines");
   myObjects.push_back(line);

   updateObjects(2.0);

   DtLine3DObject* line2 = new DtLine3DObject(exConn, id++, 
      DtVdc3DAttachPoint(cylinder->globalId()),
      DtVdc3DAttachPoint(cube->globalId()));

   DtVdcColor linecolor2(255 , 50, 50, 255);
   line2->setFlashing(true);
   line2->setColor(linecolor2);
   line2->setPattern(0xffffffff);
   line2->setLineStyle(DtVdcLineSegment::DtVdcSegmentStyleStraight);
   line2->setArrowStyle(DtVdcLineSegment::DtVdcSegmentArrowStyleArrowDouble);
   line2->setThickness(1);
   line2->setOffset(DtVector32(0, 0, 70));
   line2->setRemoteGraphicSet("3D Objects::Lines");
   myObjects.push_back(line2);

   updateObjects(2.0);

   DtSleep(4);
   hideSet("3D Objects::Lines");

   setMsg("Segmented line....");
   showSet("3D Objects::Segmented Lines");

   DtLine3DObject* segLine = new DtLine3DObject(exConn, id++,
      DtVdc3DAttachPoint(cylinder->globalId()), 
      DtVdc3DAttachPoint(cube->globalId()), 4);
   segLine->setFlashing(0);
   segLine->setOffset(DtVector32(0,0,90));
   segLine->setRemoteGraphicSet("3D Objects::Segmented Lines");
   myObjects.push_back(segLine);

   linecolor2[0] = 255;linecolor2[1] = 255; linecolor2[2] = 255; linecolor2[3] = 255;
   for (i = 0; i < 4; i++)
   {
      segLine->setColor(linecolor2, i);
      segLine->setPattern(0xbbbbbbbb, i);
      segLine->setArrowStyle(DtVdcLineSegment::DtVdcSegmentArrowStyleArrowStart, i);
      segLine->setLineStyle(DtVdcLineSegment::DtVdcSegmentStyleStraight);
      segLine->setThickness(2, i);
      segLine->setPercentage(0.25, i);
      linecolor2[i%3] -= 100;
   }

   updateObjects(2.0);

   setMsg("Changing segmented Line....");

   int dt = 25;
   inc = -1;
   for(int j = 0; j < 200; j++)
   {
      segLine->setPercentage(dt * 0.01, 0);
      for (i = 1; i < 3; i++)
      {
         segLine->setPercentage(0.25, i);
      }
      segLine->setPercentage((50 - dt) * 0.01, 3);
      dt +=inc;
      if (dt == 1 || dt == 25)
         inc *= -1;

      updateObjects();
      DtSleep(0.1);
   }
   DtSleep(2);

   showSet("3D Objects::Cuboids");
   showSet("3D Objects::Ellipsoids");
   showSet("3D Objects::Cylinders");
   showSet("3D Objects::Text");
   showSet("3D Objects::Lines");
   showSet("3D Objects::Areas");
   
   DtSleep(3);
   hideSet("3D Objects");
   
   return;
}


int main(int argc, char** argv)
{
   DtVrlApplicationInitializer appInit(argc, argv, "drawObjects");
   appInit.parseCmdLine(); 
#if DtHLA
   makVrv::DT_PROTOCOL_NAMESPACE::EpFomMapper* fixFomMapper = new
      makVrv::DT_PROTOCOL_NAMESPACE::EpFomMapper(appInit.rprFomVersion(), appInit.rprFomRevision() );
   appInit.setFomMapper( fixFomMapper );
#endif
   exConn = new DtExerciseConn(appInit); 
   exConn->setApplicationId(3, 5);
#if DtHLA
   fixFomMapper->init( exConn );
   exConn->ignoreAdvisories();
#endif

   setMsg("start demo 3D..");
   demo3d();
   setMsg("End demo 3D..");

   DtSleep(2);
   
   setMsg("Start demo 2D..");
   demo2d();
   setMsg("End demo 2D..");
   
   for (unsigned int i = 0; i < myObjects.size(); ++i)
   {
      delete myObjects[i];
   }

   delete exConn;
   return 0;
}

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