legacyStealthControl.h

Go to the documentation of this file.

/*********************************************************************
 ** Copyright (c) 2012 MaK Technologies, Inc.
 ** All rights reserved.
 *********************************************************************/
/*********************************************************************
 ** $RCSfile: absoluteVcPdu.h,v $ $Revision: 1.4 $ $State: Exp $
 *********************************************************************/

#pragma once

#include <vrvVrl/vrvVrl.h>

#include <vector>
#include <map>
#include <list>
#include <iosfwd>

#include <vlutil/vlString.h>
#include <vlutil/vlHashlist.h>
#include <vlutil/vlInetAddr.h>

#include <vl/envPoint.h>
#include <vl/envBndSphere.h>
#include <vl/envRectVol.h>
#include <vl/hostStructs.h>
#include <vl/envEllipsoid.h>
#include <vl/envLine.h>
#include <vl/envProcPub.h>
#include <vl/exerciseConn.h>
#include <vl/hostStructs.h>
#include <vl/pdu.h>
#include <vl/rprFomMap.h>
#include <vl/globalObjDes.h>
#include <vl/packets/pduHeader.h>

#include <vrfExtObjects/3dGraphicalObjectStateRecord.h>
#include <vrfExtObjects/attributeStateRecord.h>
#include <vrfExtObjects/attributeTemplateStateRecord.h>
#include <vrfExtObjects/attributeValueUpdate.h>
#include <vrfExtObjects/envFixedCylinderRecord.h>
#include <vrfExtObjects/envArticulatingCylinderRecord.h>
#include <vrfExtObjects/3dGraphicalObjectLineStateRecord.h>
#include <vrfExtObjects/2dGraphicalObjectStateRecord.h>
#include <vrfExtObjects/2dGraphicalObjectTextStateRecord.h>

#include <matrix/vlVector.h>
#include <matrix/vlTaitBryan.h>
#include <matrix/vlMath.h>

#if DtHLA
#include <vl/rprFomMap.h>
#elif DtDIS
#include <vlutil/vlInetAddr.h> // for DtInetAddr
#endif

#include <vlpi/disEnums.h>
#include <vlpi/NetStructs.h>

typedef struct 
{
   DtNetU32                    ignoreFlags;
   DtNetU8                     turnDirection;
   DtNetU8                     moveDirection;
   DtNetBoolean                reset;
   DtNetU8                     pad2;
   DtNetFloat64                position[3];
   DtNetFloat64                orientation[3];
}  DtNetMoveParams;
typedef DtNetMoveParams DtMoveParams;

typedef struct
{
   DtNetU32                    ignoreFlags;
   DtNetFloat32                radius;
   DtNetFloat32                bodyHeading;
   DtNetFloat32                pitch;
   DtNetFloat32                headingOffset;
   DtNetFloat32                pitchOffset;
   DtNetFloat32                roll;
   DtNetWorldCoordinates       pivotPoint;   

}  DtNetPivotParams;

enum DtSdcVector2DOffset
{
   DtSdcX,
   DtSdcY
};

// 
//  These are the old, original versions of the netstructs.  These work with Stealth 6.0
//  and earlier.  Starting with Stealth 6.0.1, these are cleaned up, renamed, and version
//  controlled. See the new layouts below.  Note that Stealth 6.0  and newer code WILL detect
//  the lack of a valid version number and fall back to these, so it IS backward compatible.
//
typedef struct
{
   DtNetU32 myId;
   DtNetU32 myType;
   DtNetU8  myFlags;
   DtNetU8  myUnused[3];
} DtNetSdcBasicParams;

typedef struct
{
   DtNetU32 myId;
   DtNetU32 myType;
   DtNetU8  myFlags;
   DtNetU8  myUnused[3];
   DtNetU32 myLayerId;
   DtNetU32 myFree[2];
} DtNetSdcLayer;

// layer definition
typedef struct
{
   DtNetU32 myId;
   DtNetU32 myType;
   DtNetU8  myFlags;
   DtNetU8  myUnused[3];
   DtNetU32 myNameSize;
   DtNetU32 myFree[2];
} DtNetSdcNamedObject;

typedef struct
{
   DtNetU32                      myId;
   DtNetU32                      myType;
   DtNetU8                       myFlags;       
   DtNetU8                       myAttachements;
   DtNetU8                       myPercentage;
   DtNetU8                       myUnused;
   DtNetU8                       myColor[4];   
   DtNetGlobalObjectDesignator   myEntityId[2];
   DtNetU32                      myObjectId[2];
   DtNetWorldCoordinates         myPosition[2];
   DtNetWorldCoordinates         myOffset;
   DtNetU32                      myFree[2];
}  DtNetSdcPosObject; 

typedef struct
{
   DtNetU32                      myId;
   DtNetU32                      myType;
   DtNetU8                       myFlags;       
   DtNetU8                       myAttachements;
   DtNetU8                       myPercentage;
   DtNetU8                       myUnused1;
   DtNetU8                       myColor[4];   
   DtNetGlobalObjectDesignator   myEntityId[2];
   DtNetU32                      myObjectId[2];
   DtNetWorldCoordinates         myPosition[2];
   DtNetWorldCoordinates         myOffset;
   DtNetU32                      myNameSize;
   DtNetU32                      myFree[2];
} DtNetSdcPosNamedObject;


typedef struct
{
   DtNetU32                      myId;
   DtNetU32                      myType;
   DtNetU8                       myFlags;       
   DtNetU8                       myAttachements;
   DtNetU8                       myPercentage;
   DtNetU8                       myUnused;
   DtNetU8                       myColor[4];   
   DtNetGlobalObjectDesignator   myEntityId[2];
   DtNetU32                      myObjectId[2];
   DtNetWorldCoordinates         myPosition[2];
   DtNetWorldCoordinates         myOffset;
   DtNetU32                      myPattern;
   DtNet32Vector                 myScale;
   DtNet32Vector                 myRotation;
   DtNetU32                      myFree[2];
} DtNetSdcGraphicObject;      

typedef struct
{
   DtNetU32                      myId;
   DtNetU32                      myType;
   DtNetU8                       myFlags;       
   DtNetU8                       myAttachements;
   DtNetU8                       myPercentage;
   DtNetU8                       myUnused;
   DtNetU8                       myColor[4];   
   DtNetGlobalObjectDesignator   myEntityId[2];
   DtNetU32                      myObjectId[2];
   DtNetWorldCoordinates         myPosition[2];
   DtNetWorldCoordinates         myOffset;
   DtNetU32                      myPattern;
   DtNet32Vector                 myScale;
   DtNet32Vector                 myRotation;
   DtNetU32                      myThickness;
   DtNetU32                      myFree[2];
} DtNetSdcGraphicObjectUpdate;

typedef struct
{
   DtNetU32                      myId;
   DtNetU32                      myType;
   DtNetU8                       myFlags;       
   DtNetU8                       myAttachements;
   DtNetU8                       myPercentage;
   DtNetU8                       myUnused;
   DtNetU8                       myColor[4];   
   DtNetGlobalObjectDesignator   myEntityId[2];
   DtNetU32                      myObjectId[2];
   DtNetWorldCoordinates         myPosition[2];
   DtNetWorldCoordinates         myOffset;
   DtNetU32                      myPattern;
   DtNetU32                      myThickness;
   DtNetU32                      myFree[2];
}  DtNetSdcLine; 

typedef struct
{
   DtNetU32                      myId;
   DtNetU32                      myType;
   DtNetU8                       myFlags;       
   DtNetU8                       myAttachements;
   DtNetU8                       myPercentage;
   DtNetU8                       myUnused;
   DtNetU8                       myColor[4];   
   DtNetGlobalObjectDesignator   myEntityId[2];
   DtNetU32                      myObjectId[2];
   DtNetWorldCoordinates         myPosition[2];
   DtNetWorldCoordinates         myOffset;
   DtNetU32                      myPattern;
   DtNet32Vector                 myScale;
   DtNet32Vector                 myRotation;
   DtNetWorldCoordinates         myPoints[3];
   DtNetU32                      myFree[2];
} DtNetSdcTriangle;


typedef struct
{
   DtNetU32                      myId;
   DtNetU32                      myType;
   DtNetU8                       myFlags;       
   DtNetU8                       myAttachements;
   DtNetU8                       myPercentage;
   DtNetU8                       myUnused;
   DtNetU8                       myColor[4];   
   DtNetGlobalObjectDesignator   myEntityId[2];
   DtNetU32                      myObjectId[2];
   DtNetWorldCoordinates         myPosition[2];
   DtNetWorldCoordinates         myOffset;
   DtNetU32                      myPattern;
   DtNet32Vector                 myScale;
   DtNet32Vector                 myRotation;
   DtNetWorldCoordinates         myPoints[16];
   DtNetU32                      myFree[2];
} DtNetSdcArea;

typedef struct
{
   DtNetU32       myId;
   DtNetU32       myType;
   DtNetU8        myFlags;
   DtNetU8        myUnused[3];
   DtNetU32       myGroupId;
   DtNetFloat64   myXValue;
   DtNetFloat64   myYValue;
   DtNetU32       myNameSize;
   DtNetU32       myFree[2];
} DtNetSdcAttributeValue;

typedef struct
{
   DtNetU32                      myId;
   DtNetU32                      myType;
   DtNetU8                       myFlags;       
   DtNetU8                       myAttachements;
   DtNetU8                       myPercentage;
   DtNetU8                       myUnused1;
   DtNetU8                       myColor[4];   
   DtNetGlobalObjectDesignator   myEntityId[2];
   DtNetU32                      myObjectId[2];
   DtNetWorldCoordinates         myPosition[2];
   DtNetWorldCoordinates         myOffset;
   DtNetU32                      myNameSize;
   DtNetU32                      myDisplayGroupId;
   DtNetFloat64                  myMinRange;
   DtNetFloat64                  myMaxRange;
   DtNetU32                      myFree[2];
} DtNetSdcAttribute;

typedef struct
{
   DtNetU8                 myColor[4];   
   DtNetU32                myPattern;
   DtNetU32                myThickness;
   DtNetU8                 myFlags;
   DtNetU8                 myPercentage;
   DtNetU8                 myUnused[2];
} DtNetSdcSegment;

typedef struct
{
   DtNetU32                      myId;
   DtNetU32                      myType;
   DtNetU8                       myFlags;       
   DtNetU8                       myAttachements;
   DtNetU8                       myPercentage;
   DtNetU8                       myUnused;
   DtNetU8                       myColor[4];   
   DtNetGlobalObjectDesignator   myEntityId[2];
   DtNetU32                      myObjectId[2];
   DtNetWorldCoordinates         myPosition[2];
   DtNetWorldCoordinates         myOffset;
   DtNetU32                      myNumSegments;
   DtNetU32                      myFree[2];
} DtNetSdcSegmentedLine;


//
// These are the NEW versions of the netstructs that are used by default in
// Stealth 6.0.1 and later.  Note again that Stealth 6.0.1 and later can
// receive either type of packet, but older Stealth's only support the older
// version.
//

//
// DtNetSdcDrawControlParams
//
// This is the replacement for DtNetSdcBasicParams.  It contains the fields
// that are common to ALL the Draw Control PDUs.  No PDU is actually sent
// with just this struct - but it is included in all other netstructs.
//

typedef struct
{
   DtNetU32 myMagicCookie; // This contains a bit pattern, 0x600DF00D,that 
   // tells us this is a versioned parameter.  If
   // the net parameter block does not start with
   // this pattern, the OLD netstructs are used.
   DtNetU16 myParamVersion;
   DtNetU8  myFlags;
   DtNetU8  myPadding8_1;

   DtNetU32 myId;
   DtNetU32 myType;
} DtNetSdcDrawControlParams; // 16 bytes


//
//  DtNetSdcLayerParams
//
//  This is the replacement for DtSdcNamedObject (no, NOT for DtSdcLayer).
//  It is the network representation of the DtSdcLayerPDU's parameters.
//

typedef struct
{
   DtNetSdcDrawControlParams myDrawControlParams;
   DtNetU32 myLayerNameLength;
   // Note that this is followed by a byte-array of characters which are the
   // layer name.  
} DtNetSdcLayerParams; // variable length (minimum 20 bytes)

//
//  DtNetSdcCommandParams
//
//  This is the replacement for DtNetSdcLayer(!).  It is the network
//  representation of the DtSdcCommandPDU's parameters.  The parameters
//  of the command pdu only include a layer id, which is only used for
//  the AddToLayer and RemoveFromLayer commands. The  id of the object to 
//  operate on is specified in the drawControlParams' id field, and the
//  the type of command is specified in the drawControlParams' type
//  field.

typedef struct
{
   DtNetSdcDrawControlParams myDrawControlParams;
   DtNetU32                  myLayerId;
} DtNetSdcCommandParams; // 20 bytes

//
//  DtNetSdcAttributeUpdateParams
//
//  This is the replacement for DtNetSdcAttributeUpdateValue. It is the network
//  representation of a DtSdcAttributeUpdatePDU's parameters.

typedef struct
{
   DtNetSdcDrawControlParams myDrawControlParams;
   DtNetFloat64              myXValue;
   DtNetFloat64              myYValue;
   DtNetU32                  myGroupId;
   DtNetU32                  myTextLength;
   // Note that this may be followed by a byte-array of characters which
   // represents updated text.  
} DtNetSdcAttributeUpdateParams; // 40 bytes

//
//  DtNetSdcAttachableParams
//
//  This is the replacement for DtNetSdcPosObject.  It is the network
//  representation of a DtSdcAttachablePDU's parameters.  This PDU type is never
//  sent on its own.  It is a base type shared by Attribute, Text, and
//  Graphical Object PDUs.
//
//  The myAttachments field is a DtVcObjectAttachment enumeration that specifies
//  how the object placed in the scene (2D point, 2 2D points, attached to an 
//  entity, etc.).
//

typedef struct
{
   DtNetSdcDrawControlParams     myDrawControlParams;
   DtNetU8                       myAttachments; // A DtVcObjectAttachment
   DtNetU8                       myPadding8_1;  // specifies a relative location
   // Used for attachment to lines
   // and cylinders
   DtNetU8                       myPercentage[2];// specifies a relative location
   // Used for attachment to lines
   // and cylinders
   DtNetU8                       myColor[4];    // rgba 
   DtNetGlobalObjectDesignator   myEntityId[2]; // 64 bytes each in HLA; 6 bytes
   // each in DIS. Second is used
   // to attach lines / cylinders
   // between 2 objects
   DtNetU32                      myObjectId[2]; // id(s) of other draw control
   // objects (created by the same 
   // sender)
#if DtDIS
   DtNetU32                      myPadding32_1; // For DIS, put world coords                                        
#endif                                          // on 8-byte boundary

   DtNetWorldCoordinates         myPosition[2]; // Position (and optional
   // endpoint) for attaching to
   // world coordinates
   DtNetWorldCoordinates         myOffset;      // a 3D offset
} DtNetSdcAttachableParams; // 232 bytes in HLA; 120 bytes in DIS

//
//  DtNetSdcTextParams
//
//  This is the replacement for DtNetSdcPosNamedObject.  It is the network
//  representation of a DtSdcTextPDU's parameters.
//

typedef struct
{
   DtNetSdcAttachableParams myAttachableParams;
   DtNetU32                 myTextLength;
   // Note that this will be followed by a byte-array of characters which
   // represents the text to display.  
} DtNetSdcTextParams; // variable length; minimum 236 bytes in HLA, 
// 124 bytes in DIS

//
//  DtNetSdcAttributeParams
//
//  This is the replacement for DtNetSdcAttribute.  It is the network
//  representation of a DtSdcAttributePDU's parameters.
//
//  Text can be the name of an attribute group or attribute group
//  template.
//

typedef struct
{
   DtNetSdcAttachableParams myAttachableParams;
   DtNetFloat64             myMinRange;
   DtNetFloat64             myMaxRange;
   DtNetU32                 myAttributeGroupId;
   DtNetU32                 myNameLength;
   // Note that this may be followed by a byte-array of characters which
   // represents the name of an attribute or attribute group template.  
} DtNetSdcAttributeParams; // variable length; minimum 256 bytes in HLA,
// 144 bytes in DIS

//
//  DtNetSdcLineParams
//
//  This is the replacement for DtNetSdcLine and DtNetSdcSegmentedLine.  
//  It is the network representation of a DtSdcLinePDU's parameters. 
//  An SdcLine is just a SdcSegmentedLine with one segment, simplifying
//  the network structures and class hierarchy, which previously treated
//  lines and segmented lines seperately.

typedef struct
{
   DtNetSdcAttachableParams myAttachableParams;
   DtNetU32               myNumSegments;
   DtNetU8                myCheckLos;
   DtNetU8                myProjected;
   DtNetU16               myPadding16_1;
   // This is followed by myNumSegments DtNetSdcLineSegments (define below)
} DtNetSdcLineParams; // variable length; minimum 240 bytes HLA, 128 bytes
// in DIS + segments

//
//  DtNetSdcLineSegment
//
//  This is the replacement for DtNetSdcSegment. It is the network
//  representation of one segment of a (possibly segmented) line. 

typedef struct
{
   DtNetU8                 myColor[4];   
   DtNetU32                myPattern;
   DtNetU32                myThickness;
   DtNetU8                 myFlags;
   DtNetU8                 myPercentage;
   DtNetU16                myPadding16_1;
} DtNetSdcLineSegment; // 16 bytes


//
//  DtNetSdcPolyObjectParams
//
//  This is the replacement for DtNetSdcGraphicObject.  It is the network
//  representation of a DtSdcPolyObjectPDU's parameters.

typedef struct
{
   DtNetSdcAttachableParams myAttachableParams;
   DtNetU32                 myPattern;
   DtNet32Vector            myScale;
   DtNet32Vector            myRotation;
} DtNetSdcPolyObjectParams; // 256 bytes in HLA; 148 bytes in DIS


//
//  DtNetSdcTriangleParams
//
//  This is the replacement for DtNetSdcTriangle.  It is the network
//  representation of a DtSdcTrianglePDU's parameters.  It adds a
//  field to represent the points of the triangle.

typedef struct
{
   DtNetSdcPolyObjectParams myPolyObjectParams;
   DtNetU32                 myPadding32_1;
   DtNetWorldCoordinates    myPoints[3];

} DtNetSdcTriangleParams; // 230 bytes in HLA; 192 bytes in DIS


// We are imposing a 16-vertex limit on
// this object so that it doesn't become too large

#define DT_MAX_SDC_AREA_VERTS 16

typedef struct
{
   DtNetSdcPolyObjectParams myPolyObjectParams;
   DtNetWorldCoordinates    myPoints[DT_MAX_SDC_AREA_VERTS]; 
   char                     myTextureFilename[256];  
   char                     myTextureDirectory[256]; 
   DtNetU8                  myNumVerts;       
   DtNetU8                  myNumTextureTiles;  
   DtNetU8                  myProjected;
   char                     padding1;           

} DtNetSdcAreaParams; // 1156 bytes in HLA; 1048 bytes in DIS

/* ---------------------- View Control ------------------- */
#ifndef _VIEWCONTROLP_H_GATEWAY_PROTECTION
#define _VIEWCONTROLP_H_GATEWAY_PROTECTION

#define DtNetViewerCommand DtNetU16

typedef struct
{
   DtNetU32                    ignoreFlags;
   DtNetU32                    padding;
   DtNetWorldCoordinates       world;
   DtNetEulerAngles            orientation;
} DtNetAbsoluteParams;
typedef DtNetAbsoluteParams DtAbsoluteParams;

typedef struct 
{
   DtNetU32                    ignoreFlags;
   DtNetTopoUpCoord            offset;
   DtNetEulerAngles            orientation;
   DtNetGlobalObjectDesignator attachId;
   char                        markingText[64];
} DtNetTetherParams;
typedef DtNetTetherParams DtTetherParams;

typedef struct
{
   DtNetU32                    ignoreFlags;
   DtNetFloat32                radius;
   DtNetFloat32                bodyHeading;
   DtNetFloat32                pitch;
   DtNetFloat32                headingOffset;
   DtNetFloat32                pitchOffset;
   DtNetFloat32                roll;
   DtNetGlobalObjectDesignator attachId;  
   char                        markingText[64];
} DtNetCompassParams;
typedef DtNetCompassParams DtCompassParams;

typedef struct 
{
   DtNetU32                    ignoreFlags;
   DtNetEntityCoordinates      offset;
   DtNetEulerAngles            bodyOrientation;
   DtNetGlobalObjectDesignator attachId;
   char                        markingText[64];
} DtNetMimicParams;
typedef DtNetMimicParams DtMimicParams;

typedef struct 
{
   DtNetU32                    ignoreFlags;
   DtNetFloat32                radius;
   DtNetFloat32                azimuthRate;
   DtNetFloat32                heading;
   DtNetFloat32                pitch;
   DtNetFloat32                headingOffset;
   DtNetFloat32                pitchOffset;
   DtNetFloat32                roll;
   DtNetGlobalObjectDesignator attachId;
   char                        markingText[64];
} DtNetOrbitParams;
typedef DtNetOrbitParams DtOrbitParams;

typedef struct
{
   DtNetU32               ignoreFlags;
   DtNetU32                    padding;
   DtNetWorldCoordinates      world;
   DtNetGlobalObjectDesignator trackId;
   char                        markingText[64];
} DtNetTrackParams;
typedef DtNetTrackParams DtTrackParams;

typedef struct 
{
   DtNetU32       ignoreFlags;
   DtNetEntityCoordinates  offset;
   DtNetGlobalObjectDesignator attachId;
   DtNetGlobalObjectDesignator trackId;
   char                        attachMarkingText[64];
   char                        trackMarkingText[64];
} DtNetTetherTrackParams;
typedef DtNetTetherTrackParams DtTetherTrackParams;

typedef struct 
{
   DtNetU32       ignoreFlags;
   DtNetEntityCoordinates  offset;
   DtNetGlobalObjectDesignator attachId;
   DtNetGlobalObjectDesignator trackId;
   char                        attachMarkingText[64];
   char                        trackMarkingText[64];
} DtNetMimicTrackParams;
typedef DtNetMimicTrackParams DtMimicTrackParams;

#define MAX_EIG_ENTITIES   100

typedef struct DtNetEntitiesInGroup
{
   DtNetInt32                   numToRemove; /* -1 means remove all */
   DtNetInt32                   numToAdd;
   DtNetGlobalObjectDesignator  groupId[MAX_EIG_ENTITIES];
} DtNetEntitiesInGroup;
typedef DtNetEntitiesInGroup DtEntitiesInGroup;

#define DtCMD_GROUP             (0)
#define DtCMD_WIDE_GROUP        (1)

typedef struct 
{
   DtNetU32                     ignoreFlags;
   DtNetFloat32                 radialOffset;
   DtNetFloat32                 heading;
   DtNetFloat32                 pitch;
   DtNetFloat32                 headingOffset;
   DtNetFloat32                 pitchOffset;
   DtNetU32                     groupCmd;
   DtNetEntitiesInGroup         groupIds;
} DtNetGroupParams;
typedef DtNetGroupParams DtGroupParams;

typedef struct 
{
   DtNetU32                     ignoreFlags;
   DtNetGlobalObjectDesignator  primaryId;
   DtNetGlobalObjectDesignator  secondaryId;
   DtNetEntitiesInGroup         groupIds;
} DtNetModelessParams;
typedef DtNetModelessParams DtModelessParams;

typedef struct
{
   DtNetU8 optionsBitField[8];
   DtNetFloat64 locatorRange;
   DtNetFloat64 smoothingPeriod;
   DtNetFloat64 clampRange;
   DtNetFloat64 floor;
   DtNetFloat64 timeOfDay;
   DtNetFloat64 nearClip;
   DtNetFloat64 farClip;
   DtNetFloat64 fov;
   DtNetFloat64 nearFog;
   DtNetFloat64 farFog;

   DtNetU32 overlayOption;
   DtNetU32 smoothing;
   DtNetU32 aggregateLevel;
   DtNetBoolean nextmodelset;
   DtNetBoolean prevmodelset;
   DtNetBoolean xr;
   DtNetBoolean hatlabels;

   DtNetBoolean sound;
   DtNetBoolean entityLabels;
   DtNetBoolean trailingEffects;
   DtNetBoolean trajectoryHistory;

   DtNetBoolean recording;
   DtNetBoolean aggregateHighestOnly;
   DtNetBoolean aggregatesAltitudeControlled;
   DtNetBoolean nestedAggregates;

   DtNetBoolean nestedEntities;
   DtNetBoolean groundClamping;
   DtNetBoolean followGround;
   DtNetBoolean constrainWithFloor;

   DtNetBoolean fog;
   DtNetBoolean texture;
   DtNetBoolean nexttextureset;
   DtNetBoolean prevtextureset;

   char databaseToLoad[256];
   char date[64];
   DtNetFloat32 turnrate;
   DtNetFloat32 stepsize;
   char modelsetname[32];
   char texturesetname[32];
   DtNetFloat32 terrainscale;
   DtNetFloat32 objectscale;
   DtNetBoolean skydome;
   DtNetBoolean clouds;

   // Mirroring stuff here
   DtNetBoolean mirroring;
   DtNetBoolean mirrorMessageEveryFrame;
   // 4-byte boundary
   DtNetBoolean broadcasting;
   DtNetBoolean clusteringLabels;
   DtNetBoolean tacticalGraphicsLabels;
   DtNetBoolean tacticalGraphics;

   DtNetBoolean showAggregates;
   DtNetBoolean showEmitters;

   // Video capture stuff here
   DtNetU8 videoCaptureCommand; // record, pause, unpause, or stop
   DtNetBoolean videoCaptureRecordInsets;

   DtNetU16 videoCaptureFramesPerSecond;
   DtNetU16 padding_1;

   char videoCaptureFilename[256];
   char videoCaptureDirectory[256];
   char videoCaptureFilenameBase[64];

   DtNetFloat64 blockedDistance;
   DtNetBoolean constrainedToAll;
   DtNetBoolean useNearClipForBlockedDistance;
   // lets add another 64 option flags - that should hold us a little longer
   DtNetU8 optionsBitField2[8]; 

   // and some more data
   char featureFilename[256];
   DtNetU8 featureCommand; // load or clear

} DtNetOptionsParams;

typedef DtNetOptionsParams DtOptionsParams;

#ifdef DT_CANT_HAVE_NET_UNIONS
// NOTE:
// Since we cant get a union of all the types we need to 
// make DtNetViewControlParams the size of the largest 
// component in the DtNetViewControlParams union below. 
// If you dont do this the PDU/Interactions will be to big
#if DtHLA
// In HLA DtNetModelessParams = 6540 bytes
// In DIS = 635
typedef DtNetModelessParams DtNetViewControlParams;
#else
// In HLA DtNetGroupParams = 6436
// in DIS = 635
typedef DtNetGroupParams DtNetViewControlParams;
#endif
typedef DtNetViewControlParams DtViewControlParams;

typedef DtNetAbsoluteParams DtNetabsoluteParams;
typedef DtNetTetherParams DtNettetherParams;    
typedef DtNetCompassParams DtNetcompassParams;    
typedef DtNetMimicParams DtNetmimicParams;    
typedef DtNetOrbitParams DtNetorbitParams;    
typedef DtNetTrackParams DtNettrackParams;    
typedef DtNetTetherTrackParams DtNettetherTrackParams;    
typedef DtNetMimicTrackParams DtNetmimicTrackParams;    
typedef DtNetGroupParams DtNetgroupParams;    
typedef DtNetModelessParams DtNetmodelessParams;    
typedef DtNetOptionsParams DtNetoptionsParams;    

#define DtVCPDU_PARAMS(pdu, type) (*((DtNet##type##Params *) &pdu->params))
#define DtVIEW_PARAMS(params, type) (*((DtNet##type##Params *) &params))

#else

#define DtVCPDU_PARAMS(pdu, type) (pdu->params.type)
#define DtVIEW_PARAMS(params, type) (params.type)

typedef union
{
   DtNetAbsoluteParams          absolute;
   DtNetTetherParams            tether;
   DtNetCompassParams           compass;
   DtNetMimicParams             mimic;
   DtNetOrbitParams             orbit;
   DtNetTrackParams             track;
   DtNetTetherTrackParams       tetherTrack;
   DtNetMimicTrackParams        mimicTrack;
   DtNetGroupParams             group;
   DtNetModelessParams          modeless;
   DtNetOptionsParams           options;
} DtNetViewControlParams;  
typedef DtNetViewControlParams DtViewControlParams;

#endif
#endif /*GATEWAY_PROTECTION */

typedef struct DtNetViewControlPdu
{
   DtNetPduHeader               header;
   DtNetGlobalObjectDesignator  viewerId; /* The ID of the stealth */
   DtNetGlobalObjectDesignator  senderId;
#if DtHLA
   DtNetU32                     pad;
#endif
   DtNetU16                     unused0;
   DtNetViewerCommand           command; /* attach, teleport, etc. */
   DtNetU32                     unused;
   DtNetViewControlParams       params;          
} DtNetViewControlPdu;

// \brief DtSdcVector2Ds represent vectors in 2-d space, X, Y
// 
// A DtSdcVector2D is the 2D equivalent of the 3D DtSdcVector2D
class DL_DLL_IGCONVRLINK DtSdcVector2D
{
public:

   DtSdcVector2D();

   // Construct from two doubles.
   DtSdcVector2D( const double& x, const double& y );

   // destructor
   ~DtSdcVector2D();

   // copy constructor
   DtSdcVector2D(const DtSdcVector2D& vec);

   // assignment operator
   DtSdcVector2D& operator=(const DtSdcVector2D& vec);

   // set Vector to all zeros
   void setToZero();

   // @{
   // gets/sets the x component of a Vector
   const double& x() const;
   void setX(const double& x);
   // @}

   // @{
   // gets/sets the y component of a Vector
   const double& y() const;
   void setY(const double& y);
   // @}

   // adds other to this vector
   DtSdcVector2D &operator+=(const DtSdcVector2D &other);

   // subtracts other from this vector (this - other)
   DtSdcVector2D &operator-=(const DtSdcVector2D &other);

   // subtraction
   DtSdcVector2D operator-(const DtSdcVector2D &other) const;

   // addition
   DtSdcVector2D operator+(const DtSdcVector2D &other) const;

   // multiplies this vector by scalar
   DtSdcVector2D operator*(float scale) const;

   // multiplies this vector by scalar
   DtSdcVector2D& operator*=(float scale);

   // Get the value for the specified subscript.  (int version)
   double& operator[](int ind);

   // A const version to get the value for the specified subscript
   double operator[](int ind) const;

   // Get the value for the specified subscript. (enum version)
   double& operator[](DtSdcVector2DOffset ind);

   // a const version to get the value for the specified subscript. (enum version)
   double operator[](DtSdcVector2DOffset ind) const;

   // Get whether another vector equals this vector. Warning: This
   // operation compares floats of exact equality. 
   int operator==(const DtSdcVector2D& vec) const;

   // Get whether another vector does not equal this vector. Warning:
   // this operation calles operator== which tests floats for exact equality
   int operator!=(const DtSdcVector2D& vec) const;

   // Get a string representation of the vector.
   DtString string() const;

   // Create a DtVector (with z==0) from a DtSdcVector2D
   DtVector vector3D() const;

   // Get the magnitude of the vector squared,
   // i.e. x^2 + y^2
   double magnitudeSquared() const;

   // Normalize the vector; i.e., magnitude = 1.
   void normalize();

   // Returns true of the vector is Normalized
   bool isNormalized() const;

   // Compute dot product with another vector
   double dotProduct(const DtSdcVector2D& v) const;

   // check if the vector is zero-ed out withing the tolerace passed
   bool approxEq(const DtSdcVector2D& v, const double& tolerance) const;

   // check if the magnitide of this vector is zero
   bool magnitudeIsZero() const;

   // check if the magnitide of this vector is zero, within the tolerance passed.
   // \Note This tolerance is comparied against each component of the vector,
   // not the magnitude.
   bool magnitudeIsZero(double tolerance) const;

   // prints out a formated string to the stream
   std::ostream &printDataToStream(std::ostream &str) const;

public:

   // @name These functions reveal the internal representation of DtVector
   // and should not be used. They are provided for backwards compatability
   // @{
   operator double* ();
   operator const double* () const;
   // @}

public:


   // Get a zero'ed vector.
   static const DtSdcVector2D& zero();

   // Get a (1,0) vector.
   static const DtSdcVector2D& i();

   // Get a (0,1) vector.
   static const DtSdcVector2D& j();

   // Get a vector set to all ones.
   static const DtSdcVector2D& ones();


protected:

   double myRep[2];


};

typedef const DtSdcVector2D &DtSdcConstVector2D;
typedef DtSdcVector2D &DtSdcVector2DRef;


const DtViewerCommand DtViewerPivot = DtViewerCommand(12);
const DtViewerCommand DtViewerMove = DtViewerCommand(13);
const DtViewerCommand DtViewerRequestState = DtViewerCommand(14);
const DtViewerCommand DtViewerOrthoPivot = DtViewerCommand(15);

#define DtStealthViewModeStatusStart   500
#define DtStealthViewModeStatusEnd     600

#define DtNewViewModeStatusCommand(Mode) \
   const DtViewerCommand DtViewerStatus##Mode = (DtViewerCommand) \
   ((int) DtStealthViewModeStatusStart + DtViewer##Mode);

DtNewViewModeStatusCommand(Absolute);
DtNewViewModeStatusCommand(Tether);
DtNewViewModeStatusCommand(Compass);
DtNewViewModeStatusCommand(Mimic);
DtNewViewModeStatusCommand(Turret);
DtNewViewModeStatusCommand(Orbit);
DtNewViewModeStatusCommand(Track);
DtNewViewModeStatusCommand(TetherTrack);
DtNewViewModeStatusCommand(MimicTrack);
DtNewViewModeStatusCommand(Group);
DtNewViewModeStatusCommand(Modeless);
DtNewViewModeStatusCommand(Pivot);
DtNewViewModeStatusCommand(OrthoPivot);

#define DtStealthRemoteDrawControlStart   2500
#define DtStealthRemoteDrawControlEnd     2600

#define DtNewViewerCommand(newType, value) \
   const DtViewerCommand newType = (DtViewerCommand) \
   ((int)DtStealthRemoteDrawControlStart + value);

#define EVCSTR(id) #id
#define CASE_EVCSTRING(af) case af: return (EVCSTR(af) + 2)


const int DtCURRENT_DRAW_CONTROL_VERSION = 1;

DtNewViewerCommand(DtSdcUndefined, -DtViewerOptions)

DtNewViewerCommand(DtSdcObjectPdu, 0)

// DtSdcCommand is for internal use only; it indicates the
// view command used to convey the actual draw commands below.
// The draw command itself is put into the view control PDU's
// params.type field
DtNewViewerCommand(DtSdcCommand, 10)

// Use these to send draw commands
DtNewViewerCommand(DtSdcCommandRemove, 11)
DtNewViewerCommand(DtSdcCommandHide, 12)
DtNewViewerCommand(DtSdcCommandShow, 13)  
DtNewViewerCommand(DtSdcCommandAddToLayer, 14)
DtNewViewerCommand(DtSdcCommandRemoveFromLayer, 15)
DtNewViewerCommand(DtSdcCommandShowAttribute, 16)
DtNewViewerCommand(DtSdcCommandShowTemplateAttribute, 17)
DtNewViewerCommand(DtSdcCommandHideAttribute, 18)
DtNewViewerCommand(DtSdcCommandHideTemplateAttribute, 19)

// DtSdcLine is for internal use only; it indicates the
// view command used to convey the actual line commands below.
// The draw command itself is put into the view control PDU's
// params.type field
DtNewViewerCommand(DtSdcLine, 20)

// Use these commands for 2D and 3D lines
DtNewViewerCommand(DtSdc2DLine, 21)
DtNewViewerCommand(DtSdc3DLine, 22)

// DtSdcSegmentedLine is for internal use and backwards compatibilty only;
// it indicates the view command used to convey the actual segmented line 
// commands below in version 0 (in the current version, there is no segmented
// line command - just use the line command, which can have 1 or more segments.
// The draw command itself is put into the view control PDU's
// params.type field
DtNewViewerCommand(DtSdcSegmentedLine, 30)
DtNewViewerCommand(DtSdc2DSegmentedLine, 31)
DtNewViewerCommand(DtSdc3DSegmentedLine, 32)

// DtSdcPolyObject is for internal use only; it indicates the
// view command used to convey the actual poly object commands below.
// The draw command itself is put into the view control PDU's
// params.type field
DtNewViewerCommand(DtSdcPolyObject, 40)

// Use these commands for poly objects
DtNewViewerCommand(DtSdcCircle, 41)
DtNewViewerCommand(DtSdcSphere, 42)
DtNewViewerCommand(DtSdcSquare, 43)
DtNewViewerCommand(DtSdcCube, 44)
DtNewViewerCommand(DtSdcCylinder, 45)

// DtSdcTriangle is for internal use only; it indicates the
// view command used to convey the actual triangle object commands below.
// The draw command itself is put into the view control PDU's
// params.type field
DtNewViewerCommand(DtSdcTriangle, 50)

// Use these commands for triangles
DtNewViewerCommand(DtSdc2DTriangle, 51)
DtNewViewerCommand(DtSdc3DTriangle, 52)

// Areas
DtNewViewerCommand(DtSdcArea, 53)
DtNewViewerCommand(DtSdc2DArea, 54)
DtNewViewerCommand(DtSdc3DArea, 55)

// DtSdcText is for internal use only; it indicates the
// view command used to convey the actual text commands below.
// The draw command itself is put into the view control PDU's
// params.type field
DtNewViewerCommand(DtSdcText, 60)

// Use these commmands for text
DtNewViewerCommand(DtSdc2DText, 61)
DtNewViewerCommand(DtSdc3DText, 62)

// DtSdcAttribute is for internal use only; it indicates the
// view command used to convey the actual attribute commands below.
// The draw command itself is put into the view control PDU's
// params.type field
DtNewViewerCommand(DtSdcAttribute, 70)

// Use these commands for creating attribute groups and attirbute group templates
DtNewViewerCommand(DtSdcAttributeGroupTemplate, 71)
DtNewViewerCommand(DtSdcAttributeGroup, 72)
DtNewViewerCommand(DtSdcAttributeNoValue, 73)
DtNewViewerCommand(DtSdcAttributeSingleValue, 74)
DtNewViewerCommand(DtSdcAttributeGraphicSingleValue, 75)
DtNewViewerCommand(DtSdcAttributeGraphicListValue, 76)
DtNewViewerCommand(DtSdcAttributeBitmap, 77)

// DtSdcAttributeUpdate is for internal use only; it indicates the
// view command used to convey the actual attribute update commands below.
// The draw command itself is put into the view control PDU's
// params.type field
DtNewViewerCommand(DtSdcAttributeUpdate, 80)

// Use these commands for updating attribute values
DtNewViewerCommand(DtSdcAttributeValueSet, 81)
DtNewViewerCommand(DtSdcAttributeValueReset, 82)
DtNewViewerCommand(DtSdcAttributeValueSetText, 83)

// DtSdcLayer indicates the view command used and the (create)
// layer command itself.
// The command is also put into the view control PDU's
// params.type field
DtNewViewerCommand(DtSdcLayer, 90)

class DtStealthControlPdu;
#ifndef DtViewControlPdu
typedef DtStealthControlPdu DtViewControlPdu;
#if DtDIS
typedef DtStealthControlPdu DtViewControlInteraction;
#endif
#endif

#if DtDIS
class DtExerciseConn;
class DtStealthControlPdu;
typedef DtStealthControlPdu DtStealthControlInteraction;
typedef void (*DtStealthControlInteractionCb)
(DtStealthControlInteraction *inter, void *usr);
#include <vl/interaction.h>
#endif   //! DtDIS

#define netViewControlPdu ((DtNetViewControlPdu *) netPdu)
#define DtViewControlStaticSize \
   sizeof(DtNetViewControlPdu) - sizeof(DtNetViewControlParams)

#if DtHLA
class DL_DLL_IGCONVRLINK DtStealthControlPdu : public DtPdu
#else
class DL_DLL_IGCONVRLINK DtStealthControlPdu : public DtInteraction
#endif
{
public:

   // This form is used by the enclosing interaction's Copy Constructor,
   // assignment operator, and by setVcPdu (which makes a copy of the pdu.
   static DtPdu *create(const DtNetPacket *initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);

   // This create is used to create a pdu from a net packet.  It's slightly
   // different, in that it creates a current version PDU even when an
   // older version packet is received (the current always knows how to
   // handle any version packet).  In this way, receivers can use a 
   // single PDU interface regardless of the version PDU actually sent
   // (it always looks like the current version to the receiver    
   static DtPdu *createFromNet( const DtNetPacket *initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );

   static DtU32 drawControlParamVersion( const DtNetViewControlPdu* vc );

#if DtDIS

   static void addCallback(DtExerciseConn *conn, 
      DtStealthControlInteractionCb cb, void *usr);
   static void removeCallback(DtExerciseConn *conn, 
      DtStealthControlInteractionCb cb, void *usr);

#endif

   /****************** INSPECTOR FUNCTIONS *******************/

   const DtGlobalObjectDesignator& viewerId() const;
   const DtGlobalObjectDesignator& senderId() const;
   DtViewerCommand viewerCommand() const;
   unsigned long ignoreFlags() const;
   bool statusCommand() const;

   /****************** MUTATOR FUNCTIONS *******************/

   void setViewerId(const DtGlobalObjectDesignator& id);
   void setSenderId(const DtGlobalObjectDesignator& id);
   void setIgnoreFlags(unsigned long flags);
   void setStatusCommand(bool b);

   virtual void setFromString(const char *) {}
   virtual const char *string() const {return "";}

   void printData() const;

protected:
   bool isNumber(const char* str);
   DtPduKind internalGetPduKind() const {return DtViewControlPduKind;}
   DtGlobalObjectDesignator retId;
   void setViewerCommand(DtViewerCommand com);
   DtStealthControlPdu();

protected:
   static DtStealthControlPdu* createViewControl(
      DtNetViewControlPdu *vc, DtBufferPtr buffer);

   static DtStealthControlPdu* createDrawControl(DtNetViewControlPdu *vc, 
      DtBufferPtr buffer);

   static DtStealthControlPdu* createDrawControlV0(DtNetViewControlPdu *vc, 
      DtBufferPtr buffer); 
   static DtStealthControlPdu* createDrawControlCurrent(DtNetViewControlPdu *vc, 
      DtBufferPtr buffer);

protected:
   char vcStr[400];
};

DL_DLL_IGCONVRLINK DtStealthControlPdu *DtNewStealthControlPdu(DtViewerCommand command);
DL_DLL_IGCONVRLINK DtStealthControlPdu *DtNewViewControlPdu(DtViewerCommand command);
DL_DLL_IGCONVRLINK DtStealthControlPdu *DtNewDrawControlPdu(DtViewerCommand command);
DL_DLL_IGCONVRLINK DtStealthControlPdu *DtNewDrawControlPduV0(DtViewerCommand command);

#define DtIGNORE_EAST                   (1<<0)
#define DtIGNORE_NORTH                  (1<<1)
#define DtIGNORE_HEIGHT                 (1<<2)
#define DtIGNORE_HEADING                (1<<3)
#define DtIGNORE_PITCH                  (1<<4)
#define DtIGNORE_ROLL                   (1<<5)
#define DtIGNORE_EAST_OFFSET            (1<<6)
#define DtIGNORE_NORTH_OFFSET           (1<<7)
#define DtIGNORE_HEIGHT_OFFSET          (1<<8)
#define DtIGNORE_RADIUS                 (1<<9)
#define DtIGNORE_BODY_HEADING           (1<<10)
#define DtIGNORE_HEADING_OFFSET         (1<<11)
#define DtIGNORE_PITCH_OFFSET           (1<<12)
#define DtIGNORE_FORWARD                (1<<13)
#define DtIGNORE_RIGHT                  (1<<14)
#define DtIGNORE_UP                     (1<<15)
#define DtIGNORE_BODY_PITCH             (1<<16)
#define DtIGNORE_BODY_ROLL              (1<<17)
#define DtIGNORE_AZIMUTH_RATE           (1<<18)
#define DtIGNORE_RADIAL_OFFSET          (1<<19)
#define DtIGNORE_PRIMARY_ID             (1<<20)
#define DtIGNORE_SECONDARY_ID           (1<<21)
#define DtIGNORE_GROUP_IDS              (1<<22)
#define DtIGNORE_TURN_CMD               (1<<23)
#define DtIGNORE_STEP_CMD               (1<<24)

class DtExerciseConn;
DL_DLL_IGCONVRLINK void DtStealthControlRegister(DtExerciseConn*);

#define STEALTH_CONTROL_VERSION_STRING "1.2"
#define STEALTH_CONTROL_MAJOR_VERSION 1
#define STEALTH_CONTROL_MINOR_VERSION 2
#define STEALTH_CONTROL_REVISION      0

#include <vl/hostStructs.h>
#if (VR_LINK_MINOR_VERSION == 9)
#include <vlutil/vlMachineTypes.h>
#endif
#include <matrix/vlMath.h>
#include <vl/globalObjDes.h>

#define netStealthDrawControlPdu ((DtNetViewControlPdu *) netPdu)
#define DtStealthDrawControlStaticSize (sizeof(DtNetViewControlPdu) - sizeof(DtNetViewControlParams))

//
// Vector routines.
//

#define DtSetVec2D(v, x, y)    v[DtSdcX]=x;v[DtSdcY]=y;

DL_DLL_IGCONVRLINK void      DtVecScale(const DtSdcVector2D& v, double scale_factor, DtSdcVector2D& result);
DL_DLL_IGCONVRLINK void      DtVecNeg(const DtSdcVector2D& v1, DtSdcVector2D& result); // result = -vec 

// cos of angle between v1 and V2 
DL_DLL_IGCONVRLINK double    DtVecCosProd(const DtSdcVector2D& v1, const DtSdcVector2D& v2);

DL_DLL_IGCONVRLINK double    DtVecInfNorm(const DtSdcVector2D& v1);
DL_DLL_IGCONVRLINK void      DtVecInit(DtSdcVector2D& v); // Initialize to all zeros. 

/* ||p1-p2||_{2} */
DL_DLL_IGCONVRLINK double DtDistance(const DtSdcVector2D& p1, const DtSdcVector2D& p2);  

DL_DLL_IGCONVRLINK double DtDistSqr(const DtSdcVector2D& p1, const DtSdcVector2D& p2);


std::ostream & operator << (std::ostream &str, const DtSdcVector2D &vec);

inline void DtSdcVector2D::setToZero()
{
   myRep[DtSdcX] = 0.0;
   myRep[DtSdcY] = 0.0;
}

inline const double& DtSdcVector2D::x() const
{
   return myRep[DtSdcX];
}

inline void DtSdcVector2D::setX(const double& x)
{
   myRep[DtSdcX] = x;
}

inline const double& DtSdcVector2D::y() const
{
   return myRep[DtSdcY];
}

inline void DtSdcVector2D::setY(const double& y)
{
   myRep[DtSdcY] = y;
}

// Inline DtSdcVector2D functions

inline double& DtSdcVector2D::operator[](DtSdcVector2DOffset ind)
{
   return myRep[ind];
}

inline double DtSdcVector2D::operator[](DtSdcVector2DOffset ind) const
{
   return myRep[ind];
}

inline double& DtSdcVector2D::operator[](int ind)
{
   return myRep[ind];
}

inline double DtSdcVector2D::operator[](int ind) const
{
   return myRep[ind];
}

inline DtSdcVector2D::DtSdcVector2D(
                                    const double& x,
                                    const double& y)
{
   myRep[DtSdcX] = x;
   myRep[DtSdcY] = y;
}

inline DtSdcVector2D::DtSdcVector2D()
{
   myRep[DtSdcX] = 0;
   myRep[DtSdcY] = 0;
}

inline DtSdcVector2D::DtSdcVector2D(const DtSdcVector2D& other)
{
   myRep[DtSdcX] = other[DtSdcX];
   myRep[DtSdcY] = other[DtSdcY];
}

inline DtSdcVector2D& DtSdcVector2D::operator=(const DtSdcVector2D& other)
{
   if (&other != this)
   {
      myRep[DtSdcX] = other[DtSdcX];
      myRep[DtSdcY] = other[DtSdcY];
   }
   return *this;
}

inline DtSdcVector2D::~DtSdcVector2D()
{
}

//lint -save -e777
inline int DtSdcVector2D::operator==(const DtSdcVector2D& vec) const
{
   return
      (
      myRep[DtSdcX] == vec[DtSdcX] &&
      myRep[DtSdcY] == vec[DtSdcY]
   );
}
//lint -restore

inline int DtSdcVector2D::operator!=(const DtSdcVector2D& vec) const
{
   return !operator==(vec);
}

inline DtSdcVector2D::operator double* ()
{
   return myRep;
}

inline DtSdcVector2D::operator const double* () const
{
   return myRep;
}


class DL_DLL_IGCONVRLINK DtSdcColor
{
public:

   DtSdcColor();

   DtSdcColor( unsigned r, unsigned g, unsigned b, unsigned a = 255 );

   DtSdcColor( const DtSdcColor& orig );

   DtSdcColor operator=( const DtSdcColor& orig );

   const unsigned& operator[]( int index ) const;

   unsigned& operator[]( int index );


   bool operator==(const DtSdcColor& rhs) const;

   bool operator!=(const DtSdcColor& rhs) const;

   void setHSV( unsigned hue, double saturation, double value, 
      unsigned alpha = 255 );

   unsigned red() const;

   void setRed( unsigned red );

   unsigned green() const;

   void setGreen( unsigned green );

   unsigned blue() const;

   void setBlue( unsigned blue );   

   unsigned hue() const;

   void setHue( unsigned hue );

   double saturation() const;

   void setSaturation( double saturation );

   double value() const;

   void setValue(  double value );

   unsigned alpha() const;

   void setAlpha( unsigned alpha );

   static const DtSdcColor DtSdcWhite;
   static const DtSdcColor DtSdcBlack;
   static const DtSdcColor DtSdcRed;
   static const DtSdcColor DtSdcGreen;
   static const DtSdcColor DtSdcBlue;
   static const DtSdcColor DtSdcYellow;
   static const DtSdcColor DtSdcPurple;
   static const DtSdcColor DtSdcOrange;

protected:
   void toHSV();
   void fromHSV();

protected:
   unsigned myRed;
   unsigned myGreen;
   unsigned myBlue;
   unsigned myAlpha;

   unsigned myHue;
   double mySaturation;
   double myValue;
};


class DL_DLL_IGCONVRLINK DtStealthDrawControlPdu : public DtStealthControlPdu
{
public:

   virtual const DtNetU32 objectId() const;
   virtual void  setObjectId(DtNetU32 lid);

   virtual void setType(DtNetU32 type);
   virtual DtNetU32 type() const;

   virtual DtU32 paramVersion() const;

   virtual void printData() const;
   static const char *typeString(int param);

protected:

   virtual int setInternalText(DtString str, size_t structSize);
   virtual const DtString internalText(int size, size_t structSize) const;

   // This needs to be called after initPdu when creating Pdus to send.
   // All the existing top level draw control Pdus (that aren't constructed
   // from a net buffer) call this.  It should never be called for a Pdu
   // created from a network buffer (as the version is there in the network
   // buffer already, and changing it to something else will probably result
   // in a fatal error).
   // 
   virtual void setParamVersion( DtU32 paramVersion );

protected:

   DtString myTemporalText;
};

class DtList;
class DtExerciseConn;
class DtStealthRemoteController;
class DtGlobalObjectDesignatorList;
class DtCustomRemoteControlSender;

class DtInetSocket;

typedef void (*RemoteViewChangedCb)(
                                    const DtStealthControlPdu& pdu, void* usr);


#if DtHLA 

#include <vl/hIntWEncDec.h>
#include <vl/pdu.h>

class DtStealthControlInteraction;
class DtStealthControlPdu;
class DtExerciseConn;

typedef DtStealthControlInteraction DtViewControlInteraction;

typedef void (*DtStealthControlInteractionCb)
(DtStealthControlInteraction* inter, void* usr);


class DL_DLL_IGCONVRLINK DtStealthControlInteraction : public DtInteractionWithEncDec
{
public:

   DtStealthControlInteraction();

   virtual ~DtStealthControlInteraction();

   DtStealthControlInteraction(const DtStealthControlInteraction& orig);

   DtStealthControlInteraction& operator=(const DtStealthControlInteraction& orig);

   virtual void printData() const;

   virtual const char* name() const;

   virtual const DtStealthControlPdu* vcPdu() const;
   virtual void setVcPdu(const DtStealthControlPdu& pdu);
   virtual void setFromNetPacket(const DtNetPacket* pack);


public:

   static DtInteraction* create();

   static void addCallback(DtExerciseConn* conn,
      DtStealthControlInteractionCb cb, void* usr);
   static void removeCallback(DtExerciseConn* conn,
      DtStealthControlInteractionCb cb, void* usr);

protected:

   virtual char* interactionClassToUse(DtExerciseConn* exConn) const;
   virtual DtInteractionDecoder* createDecoder(DtExerciseConn* exConn) const;
   virtual DtInteractionEncoder* createEncoder(DtExerciseConn* exConn) const;

protected:

   DtStealthControlPdu* myVcPdu;
};

inline const DtStealthControlPdu* DtStealthControlInteraction::vcPdu() const
{
   return myVcPdu;
}

inline const char* DtStealthControlInteraction::name() const
{
   return "DtStealthControlInteraction";
}

#endif


class DL_DLL_IGCONVRLINK DtStealthRemoteController
{
public:

   DtStealthRemoteController(DtCustomRemoteControlSender* sender,
      const DtGlobalObjectDesignator& targetStealthId = SEND_TO_ALL);

   DtStealthRemoteController(DtExerciseConn* c,
      const DtGlobalObjectDesignator& targetStealthId = SEND_TO_ALL);

#if DtHLA

   DtStealthRemoteController(const char* execName, const char* federateType,
      DtFomMapper* mapper = DtRprFomMapper::create(NULL),
      const char* fedFileName = NULL,
      const DtGlobalObjectDesignator& targetStealthId = SEND_TO_ALL);

   DtStealthRemoteController(const char* execName, const char* federateType,
      const char* dsoName, const char* fedFileName = NULL,
      void* fomMapInitData = NULL,
      const DtGlobalObjectDesignator& targetStealthId = SEND_TO_ALL);

#else

   DtStealthRemoteController(int port, int exercise_id,
      int site_id, int application_num,
      const DtGlobalObjectDesignator& targetStealthId = SEND_TO_ALL);

   DtStealthRemoteController(int port, const DtInetAddr& destAddr, 
      int exercise_id, int site_id, int application_num,
      const DtGlobalObjectDesignator& targetStealthId = SEND_TO_ALL);

   DtStealthRemoteController(DtInetSocket *skt, int exercise_id,
      int site_id, int application_num,
      const DtGlobalObjectDesignator& targetStealthId = SEND_TO_ALL);


#endif

   virtual ~DtStealthRemoteController();

   virtual void setTargetStealthId(const DtGlobalObjectDesignator& id);
   virtual const DtGlobalObjectDesignator& targetStealthId() const;

   virtual void setControllerId(const DtGlobalObjectDesignator& id);
   virtual const DtGlobalObjectDesignator& controllerId() const;


   virtual void addViewModeChangeCallback(
      RemoteViewChangedCb fn, void* usr,
      const DtGlobalObjectDesignator& stealthid = SEND_TO_ALL);

   virtual void removeViewModeChangeCallback(
      RemoteViewChangedCb fn, void* usr,
      const DtGlobalObjectDesignator& stealthid = SEND_TO_ALL);

   virtual void requestCurrentViewMode(
      const DtGlobalObjectDesignator& id = SEND_TO_ALL) const;

   virtual void setPrimary(const DtGlobalObjectDesignator& id) const;
   virtual void setSecondary(const DtGlobalObjectDesignator& id) const;
   virtual void setPrimarySecondary(
      const DtGlobalObjectDesignator& primary,
      const DtGlobalObjectDesignator& secondary) const;
   virtual void setGroup(const DtGlobalObjectDesignatorList& list) const;
   virtual void addToGroup(const DtGlobalObjectDesignatorList& list) const;
   virtual void removeFromGroup(const DtGlobalObjectDesignatorList& list) const;

   virtual void reset() const;

   enum Direction { Left, Right, Up, Down, Forward, Backward };
   virtual void moveEyepoint(Direction d) const;
   virtual void turnEyepoint(Direction d) const;

   virtual void setStepsize(float stepsize) const;
   virtual void setTurnrate(float turnrate) const;

   virtual void increaseStepsize() const;
   virtual void increaseTurnrate() const;
   virtual void decreaseStepsize() const;
   virtual void decreaseTurnrate() const;

   virtual void set(
      const DtVector* geoc = NULL,
      const DtTaitBryan* ori = NULL) const;

   virtual void setMode(DtViewerCommand m, 
      const DtVector* geocPos = NULL, 
      const DtTaitBryan* geocOri = NULL) const;

   virtual void setAbsoluteMode(
      const DtVector* geoc = NULL, 
      const DtTaitBryan* ori = NULL) const;

   virtual void setCompassMode(
      const DtGlobalObjectDesignator* primary = NULL,
      const float* radius = NULL, 
      const float* azimuth = NULL, 
      const float* elevation = NULL) const;

   virtual void setMimicMode(
      const DtGlobalObjectDesignator* primary = NULL, 
      const DtVector* offset = NULL) const;

   virtual void setTurretMode(
      const DtGlobalObjectDesignator* primary, 
      const DtVector* offset) const;

   virtual void setOrbitMode(
      const DtGlobalObjectDesignator* primary = NULL,
      const float* radius = NULL, 
      const float* azimuth = NULL, 
      const float* elevation = NULL, 
      const float* azimuthRate = NULL) const;

   virtual void setPivotMode(
      const DtVector* pivotPt = NULL, 
      const float* radius = NULL, 
      const float* azimuth = NULL, 
      const float* elevation = NULL) const;

   virtual void setTetherMode(
      const DtGlobalObjectDesignator* primary = NULL,
      const DtVector* offset = NULL, 
      const DtTaitBryan* ori = NULL) const;

   virtual void setTrackMode(
      const DtGlobalObjectDesignator* primary = NULL,
      const DtVector* geoc = NULL) const;

   virtual void setMimicTrackMode(
      const DtGlobalObjectDesignator* attach = NULL,
      const DtGlobalObjectDesignator* track = NULL, 
      const DtVector* offset = NULL) const;

   virtual void setTetherTrackMode(
      const DtGlobalObjectDesignator* attach = NULL,
      const DtGlobalObjectDesignator* track = NULL, 
      const DtVector* offset = NULL) const;

   virtual void setGroupMode(
      const DtGlobalObjectDesignatorList* grp = NULL,
      const float* radius = NULL, 
      const float* azimuth = NULL, 
      const float* elevation = NULL) const; 

   virtual void setWideGroupMode(
      const DtGlobalObjectDesignatorList* grp = NULL,
      const float* radius = NULL, 
      const float* azimuth = NULL,
      const float* elevation = NULL) const; 


   virtual void setOverlayEnabled(bool b) const;

   virtual void setSmoothing(DtSmoothingOption option) const;

   virtual void setSmoothingPeriod(double period) const;

   virtual void setSoundEnabled(bool onOff) const;

   virtual void setEntityLabelsEnabled(bool onOff) const;

   virtual void setTrailingEffectsEnabled(bool onOff) const;

   virtual void setTrajectoryHistoriesEnabled(bool onOff) const;

   virtual void setAggregateLevel(int level) const;

   virtual void setAggregateHighestOnly(bool onOff) const;

   virtual void setGroundClampingEnabled(bool onOff) const;

   virtual void setGroundClampRange(double range) const;

   virtual void setTimeOfDay(double time) const;

   virtual void setNearClippingPlane(double clip) const;

   virtual void setFarClippingPlane(double clip) const;

   virtual void setVerticalFieldOfView(double fov) const;

   virtual void setFogEnabled(bool onOff) const;

   virtual void setDatabaseToLoad(const DtString& db) const;

   virtual void setDate(const DtString& str) const;

   virtual void exit();

   virtual void setClouds(bool b);

   virtual void setSkyDome(bool b);

   virtual void setMirrorMessageEveryFrame(bool b);

   virtual void setMirroring(bool b);

   virtual void setBroadcasting(bool b);

   virtual void setClusteringLabels(bool b);

   virtual void setTacticalGraphicsLabels(bool b);

   virtual void setShowAggregates(bool b);

   virtual void setShowEmitters(bool b);

   virtual void setXr(bool b);

   virtual void setHatLabels(bool b);

   virtual void setCurrentModelSet(const DtString& str);

   virtual void setNextModelSet();

   virtual void setPrevModelSet();

   virtual void setCurrentTextureSet(const DtString& str);

   virtual void setNextTextureSet();

   virtual void setPrevTextureSet();

   virtual void setTerrainScale(double s);

   virtual void setObjectScale(double s);

   virtual void startVideoRecording();

   virtual void startVideoRecording( const DtString& filename );

   virtual void stopVideoRecording();

   virtual void pauseVideoRecording();

   virtual void unpauseVideoRecording();

   virtual void setVideoCaptureRecordInsets(bool videoCaptureRecordInsets);

   virtual void setVideoCaptureFramesPerSecond(int videoCaptureFramesPerSecond);

   virtual void setVideoCaptureFilenameBase(
      const DtString& videoCaptureFilenameBase);

   virtual void setVideoCaptureDirectory(
      const DtString& videoCaptureDirectory);

   virtual void setConstrainWithFloor( bool b );

   virtual void setFloor( double h );

   virtual void setConstrainViewToAll( bool b );

   virtual void setBlockedDistance( double d );

   virtual void setUseNearClipForBlockedDistance( bool b );

   virtual void loadFeatures( const DtString& filename );

   virtual void clearFeatures();

   virtual void setIgnoreCommandsSentFromUs(bool);

public:

   virtual void send(const DtStealthControlPdu& pdu) const;

public:

   static const DtGlobalObjectDesignator SEND_TO_ALL;

protected:

   static void processStealthControlCb(
      DtStealthControlInteraction* inter, void* usr);

   virtual void processStealthControl(
      DtStealthControlInteraction* inter) const;

   virtual void sendGroupPdu(
      const DtGlobalObjectDesignatorList* grp,
      const float* radius, const float* azimuth, 
      const float* elevation, int grpCmd) const; 

protected:

   DtGlobalObjectDesignator myId;
   DtGlobalObjectDesignator myTargetId;
   DtList* myViewChangedCbList;
   DtExerciseConn* myExConn;
   DtCustomRemoteControlSender* mySender;
   bool myCreatedExConn;
   bool myIgnoreCommandsSentFromUs;
};


class DtStealthDrawControlPdu;

class DL_DLL_IGCONVRLINK DtSdcObject
{
public:
   DtSdcObject(DtExerciseConn* exConn, unsigned id, const DtString& objName);

   virtual ~DtSdcObject();

private:
   DtSdcObject();

   DtSdcObject(const DtSdcObject& orig);

   DtSdcObject& operator=(const DtSdcObject& rhs);


public:
   virtual unsigned id() const;

   virtual void setId( unsigned id );

   virtual const DtGlobalObjectDesignator& globalId() const;

   virtual void setVisible(bool yesNo);

   virtual bool visible() const;

   virtual bool flashing() const;

   virtual void setFlashing(bool yesNo);

   virtual const DtSdcColor& color() const;

   virtual void setColor(const DtSdcColor& color);

   virtual void setRemoteGraphicSet(const std::string& setName);

   virtual void update() = 0;

protected:
   unsigned                      myId;
   DtEnvironmentProcessPublisher myPublisher;
   bool                          myVisible;
   DtSdcColor                    myEmptyColor;
};

class DL_DLL_IGCONVRLINK DtTetherTrackVCPdu : public DtStealthControlPdu
{
public:

   DtTetherTrackVCPdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
   DtTetherTrackVCPdu(const DtNetViewControlPdu *initial,
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);


   DtConstVector offset() const;
   void setOffset(DtConstVector loc);

   const DtGlobalObjectDesignator& attachId() const;
   void setAttachId(const DtGlobalObjectDesignator& id);

   const DtGlobalObjectDesignator& trackId() const;
   void setTrackId(const DtGlobalObjectDesignator& id);

   const DtString& trackMarkingText() const;
   void setTrackMarkingText(const DtString& markingText);

   const DtString& attachMarkingText() const;
   void setAttachMarkingText(const DtString& markingText);


   void setFromString(const char *str);
   const char *string() const;
   void printData() const;

protected:
   DtVector theVec;
   DtGlobalObjectDesignator theId;
   DtString myAttachMarkingText;
   DtString myTrackMarkingText;
};

class DL_DLL_IGCONVRLINK DtTetherVCPdu : public DtStealthControlPdu
{
public:

   /******************* STANDARD CONSTRUCTORS ****************/

   DtTetherVCPdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
   DtTetherVCPdu(const DtNetViewControlPdu *initial,
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);

   /****************** INSPECTOR FUNCTIONS *******************/

   DtConstVector topoUpOffset() const;
   const DtTaitBryan &orientation() const;
   const DtGlobalObjectDesignator& attachId() const;
   const DtString& markingText() const;

   /****************** MUTATOR FUNCTIONS *******************/    

   void setTopoUpOffset(DtConstVector offset);
   void setOrientation(const DtTaitBryan &ori);
   void setAttachId(const DtGlobalObjectDesignator& id);
   void setMarkingText(const DtString& markingText);


   void setFromString(const char *str);
   const char *string() const;
   void printData() const;

protected:
   DtVector theVec;
   DtTaitBryan theAngles;
   DtGlobalObjectDesignator theId;
   DtString myMarkingText;

};

class DL_DLL_IGCONVRLINK DtTrackVCPdu : public DtStealthControlPdu
{
public:


   DtTrackVCPdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
   DtTrackVCPdu(const DtNetViewControlPdu *initial,
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);


   DtConstVector worldLocation() const;
   const DtGlobalObjectDesignator& trackId() const;

   void setWorldLocation(DtConstVector loc);
   void setTrackId(const DtGlobalObjectDesignator& id);

   const DtString& markingText() const;
   void setMarkingText(const DtString& markingText);


   void setFromString(const char *str);
   const char *string() const;
   void printData() const;

protected:

   DtVector theVec;
   DtGlobalObjectDesignator theId;
   DtString myMarkingText;

};

class DL_DLL_IGCONVRLINK DtUnknownStealthControlPdu : public DtStealthControlPdu
{
public:

   DtUnknownStealthControlPdu(const DtNetViewControlPdu *initial,
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER)
   {
      initPdu(initial, buffer);
   }
};

class DL_DLL_IGCONVRLINK DtAbsoluteVCPdu : public DtStealthControlPdu
{
  public:
    
/******************* STANDARD CONSTRUCTORS ****************/

    DtAbsoluteVCPdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);

    DtAbsoluteVCPdu(const DtNetViewControlPdu *initial,
       DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);

/****************** INSPECTOR FUNCTIONS *******************/

    DtConstVector worldLocation() const;
    const DtTaitBryan &orientation() const;

/****************** MUTATOR FUNCTIONS *******************/    

    void setWorldLocation(DtConstVector loc);
    void setOrientation(const DtTaitBryan &ori);

    void setFromString(const char *str);
    const char *string() const;
    void printData() const;

  protected:
    DtVector theVec;
    DtTaitBryan theAngles;
};

class DL_DLL_IGCONVRLINK DtCompassVCPdu : public DtStealthControlPdu
{
  public:
    

    DtCompassVCPdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
    DtCompassVCPdu(const DtNetViewControlPdu *initial,
       DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);

    float radius() const;
    void setRadius(float r);

    float bodyHeading() const;
    void setBodyHeading(float h);

    float pitch() const;
    void setPitch(float p);

    float headingOffset() const;
    void setHeadingOffset(float o);

    float pitchOffset() const;
    void setPitchOffset(float p);

    float roll() const;
    void setRoll(float r);

    const DtGlobalObjectDesignator& attachId() const;
    void setAttachId(const DtGlobalObjectDesignator& id);

    const DtString& markingText() const;
    void setMarkingText(const DtString& markingText);

    void setFromString(const char *str);
    const char *string() const;
    void printData() const;

  protected:
    DtGlobalObjectDesignator theId;
    DtString myMarkingText;
};

class DtCustomRemoteControlSender
{
public:
   DtCustomRemoteControlSender() {}
   virtual ~DtCustomRemoteControlSender() {}
   virtual void send(const char* packet, int size) = 0;
};

class DL_DLL_IGCONVRLINK DtGroupVCPdu : public DtStealthControlPdu
{
  public:
    
/******************* STANDARD CONSTRUCTORS ****************/

    DtGroupVCPdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
    DtGroupVCPdu(const DtNetViewControlPdu *initial,
       DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);

/****************** INSPECTOR FUNCTIONS *******************/

    float radialOffset() const;
    float heading() const;
    float pitch() const;
    float headingOffset() const;
    float pitchOffset() const;
    int groupCmd() const;
    int numEntitiesToRemove() const;
    int numEntitiesToAdd() const;
    const DtGlobalObjectDesignator& entityToRemove(int n) const;
    const DtGlobalObjectDesignator& entityToAdd(int n) const;

/****************** MUTATOR FUNCTIONS *******************/    
    
    void setRadialOffset(float o);
    void setHeading(float h);
    void setPitch(float p);
    void setHeadingOffset(float o);
    void setPitchOffset(float o);
    void setGroupCmd(int c);
    void setNumEntitiesToRemove(int n);
    void setNumEntitiesToAdd(int n);
    void setEntityToRemove(int n, const DtGlobalObjectDesignator& id);
    void setEntityToAdd(int n, const DtGlobalObjectDesignator& id);

    void setFromString(const char *str);
    const char *string() const;
    void printData() const;

  protected:
    DtGlobalObjectDesignator theId;
};

#if DtHLA 

#include <vl/interDecoder.h>

class  DtStealthControlInteraction;
class DtStealthControlDecoder;
typedef DtStealthControlDecoder DtViewControlDecoder;


#define DtDECLARE_VIEW_CONTROL_PARAM_DECODER(paramName) \
   DtDECLARE_PARAM_DECODER(DtStealthControlInteraction, paramName)


class DL_DLL_IGCONVRLINK DtStealthControlDecoder : public DtInteractionDecoder
{
public:

   DtStealthControlDecoder(DtExerciseConn* exConn,
      DtInterClassDesc* classDesc);

   virtual ~DtStealthControlDecoder();

   DtStealthControlDecoder(const DtStealthControlDecoder& orig);

   DtStealthControlDecoder& operator=(const DtStealthControlDecoder& orig);

protected:


   DtDECLARE_VIEW_CONTROL_PARAM_DECODER(ViewControlPdu);
};
#endif

#if   DtHLA 

#include <vl/interEncoder.h>

class DtStealthControlInteraction;
class DtStealthControlEncoder;
typedef DtStealthControlEncoder DtViewControlEncoder;

#define DtDECLARE_VIEW_CONTROL_PARAM_ENCODER(paramName) \
   DtDECLARE_PARAM_ENCODER(DtStealthControlInteraction, paramName)

#define DtDEFINE_SIMPLE_VIEW_CONTROL_PARAM_ENCODER(paramName, netType, inspector) \
   DtDEFINE_SIMPLE_PARAM_ENCODER(DtStealthControlEncoder, DtStealthControlInteraction, \
                              paramName, netType, \
                              inspector)

class DL_DLL_IGCONVRLINK DtStealthControlEncoder : public DtInteractionEncoder
{
public:

   DtStealthControlEncoder(DtExerciseConn* exConn,
      DtInterClassDesc* classDesc);

   virtual ~DtStealthControlEncoder();

   DtStealthControlEncoder(const DtStealthControlEncoder& orig);

   DtStealthControlEncoder& operator=(const DtStealthControlEncoder& orig);

protected:


   DtDECLARE_VIEW_CONTROL_PARAM_ENCODER(ViewControlPdu);
};

#endif


class DL_DLL_IGCONVRLINK DtMimicTrackVCPdu : public DtStealthControlPdu
{
  public:
    

    DtMimicTrackVCPdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
    DtMimicTrackVCPdu(const DtNetViewControlPdu *initial,
       DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);


    DtConstVector offset() const;
    void setOffset(DtConstVector loc);

    const DtGlobalObjectDesignator& attachId() const;
    void setAttachId(const DtGlobalObjectDesignator& id);

    void setTrackId(const DtGlobalObjectDesignator& id);
    const DtGlobalObjectDesignator& trackId() const;

    const DtString& trackMarkingText() const;
    void setTrackMarkingText(const DtString& markingText);

    const DtString& attachMarkingText() const;
    void setAttachMarkingText(const DtString& markingText);


    void setFromString(const char *str);
    const char *string() const;
    void printData() const;

  protected:
    DtVector theVec;
    DtGlobalObjectDesignator theId;
    DtString myAttachMarkingText;
    DtString myTrackMarkingText;

};

class DL_DLL_IGCONVRLINK DtMimicVCPdu : public DtStealthControlPdu
{
  public:
    

    DtMimicVCPdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
    DtMimicVCPdu(const DtNetViewControlPdu *initial,
       DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);

    
    DtConstVector offset() const;
    void setOffset(DtConstVector offset);

    const DtTaitBryan &bodyOrientation() const;
    void setBodyOrientation(const DtTaitBryan &ori);

    const DtGlobalObjectDesignator& attachId() const;
    void setAttachId(const DtGlobalObjectDesignator& id);

    const DtString& markingText() const;
    void setMarkingText(const DtString& markingText);

    void setFromString(const char *str);
    const char *string() const; 
    void printData() const;

  protected:
    DtGlobalObjectDesignator theId;
    DtVector theVec;
    DtTaitBryan theAngles;
    DtString myMarkingText;

};

class DL_DLL_IGCONVRLINK DtOffsetMimicVCPdu : public DtMimicVCPdu
{
public:
    DtOffsetMimicVCPdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
    DtOffsetMimicVCPdu(const DtNetViewControlPdu *initial,
       DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);

};

class DL_DLL_IGCONVRLINK DtModelessVCPdu : public DtStealthControlPdu
{
  public:
    DtModelessVCPdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
    DtModelessVCPdu(const DtNetViewControlPdu *initial,
       DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);

    const DtGlobalObjectDesignator& primary() const;
    void setPrimary(const DtGlobalObjectDesignator& id);

    const DtGlobalObjectDesignator& secondary() const;    
    void setSecondary(const DtGlobalObjectDesignator& id);    

    int numEntitiesToRemove() const;
    void setNumEntitiesToRemove(int n);

    int numEntitiesToAdd() const;
    void setNumEntitiesToAdd(int n);

    const DtGlobalObjectDesignator& entityToRemove(int n) const;
    void setEntityToRemove(int n, const DtGlobalObjectDesignator& id);

    const DtGlobalObjectDesignator& entityToAdd(int n) const;
    void setEntityToAdd(int n, const DtGlobalObjectDesignator& id);

    void printData() const;

  protected:
    DtGlobalObjectDesignator theId;
};

class DL_DLL_IGCONVRLINK DtMoveVCPdu : public DtStealthControlPdu
{
public:

    enum Direction { Left, Right, Up, Down, Forward, Backward };

public:
    
    DtMoveVCPdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
    DtMoveVCPdu(const DtNetViewControlPdu *initial,
       DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
 
    virtual ~DtMoveVCPdu() {}
    
    bool reset() const;
    void setReset(bool b);

    Direction turn() const;
    void setTurn(Direction d);

    Direction move() const;
    void setMove(Direction d);

    void setPosition(const DtVector& v);
    DtVector position() const;    

    void setOrientation(const DtTaitBryan& o);
    DtTaitBryan orientation() const;    

    virtual void setFromString(const char *str);
    virtual const char *string() const;
    virtual void printData() const;
};

class DtOptionsPdu;
typedef DtOptionsPdu DtOptionsVCPdu;

class DL_DLL_IGCONVRLINK DtOptionsPdu : public DtStealthControlPdu
{
public:

   static const DtStealthOption DtStealthStepsize;
   static const DtStealthOption DtStealthTurnrate;
   static const DtStealthOption DtStealthIncStepsize;
   static const DtStealthOption DtStealthIncTurnrate;
   static const DtStealthOption DtStealthDecStepsize;
   static const DtStealthOption DtStealthDecTurnrate;
   static const DtStealthOption DtStealthDate;
   static const DtStealthOption DtStealthXREnabled;
   static const DtStealthOption DtStealthHATenabled;
   static const DtStealthOption DtStealthNextModelSet;
   static const DtStealthOption DtStealthPrevModelSet;
   static const DtStealthOption DtStealthSetCurrentModelSet;
   static const DtStealthOption DtStealthNextTextureSet;
   static const DtStealthOption DtStealthPrevTextureSet;
   static const DtStealthOption DtStealthSetCurrentTextureSet;
   static const DtStealthOption DtStealthTerrainScale;
   static const DtStealthOption DtStealthObjectScale;
   static const DtStealthOption DtStealthClouds;
   static const DtStealthOption DtStealthSkyDome;
   static const DtStealthOption DtStealthExit;
   static const DtStealthOption DtStealthMirroring;
   static const DtStealthOption DtStealthMirrorMessageEveryFrame;
   static const DtStealthOption DtStealthBroadcasting;
   static const DtStealthOption DtStealthClusteringLabels;
   static const DtStealthOption DtStealthTacticalGraphicsLabels;
   static const DtStealthOption DtStealthTacticalGraphics;
   static const DtStealthOption DtStealthShowAggregates;
   static const DtStealthOption DtStealthShowEmitters;
   static const DtStealthOption DtStealthVideoCaptureCommand;
   static const DtStealthOption DtStealthVideoCaptureFilename;
   static const DtStealthOption DtStealthVideoCaptureDirectory;
   static const DtStealthOption DtStealthVideoCaptureFilenameBase;
   static const DtStealthOption DtStealthVideoCaptureRecordInsets;
   static const DtStealthOption DtStealthVideoCaptureFramesPerSecond;
   static const DtStealthOption DtStealthConstrainToAll;
   static const DtStealthOption DtStealthBlockedDistance;
   static const DtStealthOption DtStealthUseNearClipForBlockedDistance;
   static const DtStealthOption DtStealthFeatureFilename;
   static const DtStealthOption DtStealthFeatureCommand;

public:

   typedef enum
   {
      Stop    = 0,
      Pause   = 1,
      Unpause = 2,
      Record  = 3
      
   } DtStealthControlVideoCaptureCommand;

   typedef enum
   {
      FeatureLoad    = 0,
      FeatureClear   = 1
      
   } DtStealthControlFeatureCommand;
   
public:
    
/******************* STANDARD CONSTRUCTORS ****************/

   DtOptionsPdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
   DtOptionsPdu(const DtNetViewControlPdu *initial,
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);

/****************** MUTATOR FUNCTIONS *******************/

   void setOverlayOption(DtOverlayOption option);
   void setLocatorRange(double range);
   void setSmoothing(DtSmoothingOption option);
   void setSmoothingPeriod(double period);
   void setSound(bool onOff);
   void setEntityLabels(bool onOff);
   void setTrailingEffects(bool onOff);
   void setTrajectoryHistory(bool onOff);
   void setRecording(bool onOff);
   void setAggregateLevel(int level);
   void setAggregateHighestOnly(bool onOff);
   void setAggregatesAltitudeControlled(bool onOff);
   void setNestedAggregates(bool onOff);
   void setNestedEntities(bool onOff);
   void setGroundClamping(bool onOff);
   void setClampRange(double range);
   void setFollowGround(bool onOff);
   void setConstrainWithFloor(bool onOff);
   void setFloor(double height);
   void setTimeOfDay(double time);
   void setNearClip(double clip);
   void setFarClip(double clip);
   void setFov(double fov);
   void setFog(bool onOff);
   void setNearFog(double fog);
   void setFarFog(double fog);
   void setTexture(bool onOff);
   void setDatabaseToLoad(const DtString& db);
   void setStepsize(float step);
   void setTurnrate(float step);
   void setDate(const DtString& date);
   void setIncrementStepsize(bool b);
   void setIncrementTurnrate(bool b);
   void setDecrementStepsize(bool b);
   void setDecrementTurnrate(bool b);
   void setXr(bool onOff);
   void setHatLabels(bool onOff);
   void setCurrentModelSet(const DtString& setname);
   void setShowNextModelSet(bool b);
   void setShowPrevModelSet(bool b);
   void setCurrentTextureSet(const DtString& setname);
   void setShowNextTextureSet(bool b);
   void setShowPrevTextureSet(bool b);
   void setTerrainScale(double s);
   void setObjectScale(double s);
   void setExit(bool b);
   void setSkyDome(bool b);
   void setClouds(bool b);
   void setMirroring(bool b);
   void setMirrorMessageEveryFrame(bool b);
   void setBroadcasting(bool b);
   void setClusteringLabels(bool b);
   void setTacticalGraphicsLabels(bool b);
   void setTacticalGraphics(bool b);
   void setShowAggregates(bool b);
   void setShowEmitters(bool b);
   void setVideoCaptureCommand(
      DtStealthControlVideoCaptureCommand videoCaptureCommand);
   void setVideoCaptureRecordInsets(bool videoCaptureRecordInsets);
   void setVideoCaptureFramesPerSecond(int videoCaptureFramesPerSecond);
   void setVideoCaptureFilename(const DtString& videoCaptureFilename);
   void setVideoCaptureFilenameBase(const DtString& videoCaptureFilenameBase);
   void setVideoCaptureDirectory(const DtString& videoCaptureDirectory);
   void setConstrainToAll( bool b );
   void setUseNearClipForBlockedDistance( bool b );
   void setBlockedDistance( double distance );
   void setFeatureFilename( const DtString& featureFilename );
   void setFeatureCommand( DtStealthControlFeatureCommand featureCommand );


/****************** INSPECTOR FUNCTIONS *******************/    

   bool optionPresent(DtStealthOption option) const;

   DtOverlayOption overlayOption() const;
   double locatorRange() const;
   DtSmoothingOption smoothing() const;
   double smoothingPeriod() const;
   bool sound() const;
   bool entityLabels() const;
   bool trailingEffects() const;
   bool trajectoryHistory() const;
   bool recording() const;
   int aggregateLevel() const;
   bool aggregateHighestOnly() const;
   bool aggregatesAltitudeControlled() const;
   bool nestedAggregates() const;
   bool nestedEntities() const;
   bool groundClamping() const;
   double clampRange() const;
   bool followGround() const;
   bool constrainWithFloor() const;
   double floor() const;
   double timeOfDay() const;
   double nearClip() const;
   double farClip() const;
   double fov() const;
   bool fog() const;
   double nearFog() const;
   double farFog() const;
   bool texture() const;
   const DtString databaseToLoad() const;
   float stepsize() const;
   float turnrate() const;
   bool incrementStepsize() const;
   bool incrementTurnrate() const;
   bool decrementStepsize() const;
   bool decrementTurnrate() const;
   const DtString date() const;
   bool xr() const;
   bool hatLabels() const;
   const DtString currentModelSet() const;
   bool showNextModelSet() const;
   bool showPrevModelSet() const;
   const DtString currentTextureSet() const;
   bool showNextTextureSet() const;
   bool showPrevTextureSet() const;
   double terrainScale() const;
   double objectScale() const;
   bool exit() const;
   bool skyDome() const;
   bool clouds() const;
   bool mirroring() const;
   bool mirrorMessageEveryFrame() const;
   bool broadcasting() const;
   bool clusteringLabels() const;
   bool tacticalGraphicsLabels() const;
   bool tacticalGraphics() const;
   bool showAggregates() const;
   bool showEmitters() const;
   DtStealthControlVideoCaptureCommand videoCaptureCommand() const;
   bool videoCaptureRecordInsets() const;
   int videoCaptureFramesPerSecond() const;
   const DtString videoCaptureFilename() const;
   const DtString videoCaptureFilenameBase() const;
   const DtString videoCaptureDirectory() const;
   bool useNearClipForBlockedDistance() const;
   bool constrainedToAll() const;
   double blockedDistance() const;
   DtStealthControlFeatureCommand featureCommand() const;
   const DtString featureFilename() const;

   void printData() const;

   void setFromString(const char *str);
   const char* string() const;

protected:

   void setOptionPresent(DtStealthOption option);
   void clearOptionPresent(DtStealthOption option);

protected:

   DtString myStr;
};

class DL_DLL_IGCONVRLINK DtOrbitVCPdu : public DtStealthControlPdu
{
  public:
    

    DtOrbitVCPdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
    DtOrbitVCPdu(const DtNetViewControlPdu *initial,
       DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
    
    float radius() const;
    void setRadius(float r);

    float azimuthRate() const;
    void setAzimuthRate(float a);

    float heading() const;
    void setHeading(float h);

    float pitch() const;
    void setPitch(float p);

    float headingOffset() const;
    void setHeadingOffset(float o);

    float pitchOffset() const;
    void setPitchOffset(float p);

    float roll() const;
    void setRoll(float r);

    const DtString& markingText() const;
    void setMarkingText(const DtString& markingText);


    const DtGlobalObjectDesignator& attachId() const;
    void setAttachId(const DtGlobalObjectDesignator& id);

    void setFromString(const char *str);
    const char *string() const;
    void printData() const;
    
  protected:
    DtGlobalObjectDesignator theId;
    DtString myMarkingText;

};

class DL_DLL_IGCONVRLINK DtPivotVCPdu : public DtStealthControlPdu
{

public:
    

    DtPivotVCPdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
    DtPivotVCPdu(const DtNetViewControlPdu *initial,
       DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
 
    virtual ~DtPivotVCPdu() {}
    
    virtual float radius() const;
    virtual void setRadius(float r);

    virtual float bodyHeading() const;
    virtual void setBodyHeading(float h);

    virtual float pitch() const;
    virtual void setPitch(float p);

    virtual float headingOffset() const;
    virtual void setHeadingOffset(float o);

    virtual float pitchOffset() const;
    virtual void setPitchOffset(float p);

    virtual float roll() const;
    virtual void setRoll(float r);

    virtual const DtVector& pivotPoint() const;
    virtual void setPivotPoint(const DtVector& v);

    virtual void setFromString(const char *str);
    virtual const char *string() const;
    virtual void printData() const;

protected:

    mutable DtVector myPivotPoint;
};

class DL_DLL_IGCONVRLINK DtRequestStateVCPdu : public DtStealthControlPdu
{
public:
    
   DtRequestStateVCPdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER)
   {
      initPdu(DtViewControlStaticSize, buffer);
      setViewerCommand(DtViewerRequestState);
   }

   DtRequestStateVCPdu(const DtNetViewControlPdu *initial,
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER)
   {
      initPdu(initial, buffer);
   }
};

class DL_DLL_IGCONVRLINK DtSdc2DPositionedObject : public DtSdcObject
{
public:
   DtSdc2DPositionedObject(DtExerciseConn* exConn, unsigned id, 
      const DtString& objName);
   
   // \brief Virtual destructor
   virtual ~DtSdc2DPositionedObject();
  
private:
   DtSdc2DPositionedObject();

   DtSdc2DPositionedObject(const DtSdc2DPositionedObject& orig);

   DtSdc2DPositionedObject& operator=(const DtSdc2DPositionedObject& rhs);

public:
   virtual DtSdcVector2D position() const = 0;
   
   virtual void setPosition( const DtSdcVector2D& position ) = 0;
};


class DL_DLL_IGCONVRLINK DtSdc3DAttachPoint
{
public:
typedef enum 
{
   attachmentTypeUndefined = 0,
   attachmentTypeScene = 1,
   attachmentTypeEntity = 2,
   attachmentTypeDrawObject = 3
} DtSdc3DAttachmentType;

public:
   DtSdc3DAttachPoint( const DtVector& location );
   
   DtSdc3DAttachPoint( const DtGlobalObjectDesignator& entityId );
    
   DtSdc3DAttachPoint( const DtGlobalObjectDesignator& drawObjectId, double relativePosition);
   
   DtSdc3DAttachPoint( const DtSdc3DAttachPoint& orig );
   
   DtSdc3DAttachPoint& operator=( const DtSdc3DAttachPoint& rhs );

   virtual ~DtSdc3DAttachPoint();

   DtSdc3DAttachPoint();
   
public:

   virtual DtSdc3DAttachmentType attachmentType() const;
   
   virtual DtVector location() const;
   virtual DtVector& location();
   
   virtual void setLocation( DtVector location );
   
   virtual const DtGlobalObjectDesignator& drawObjectId() const;
   
   virtual void setDrawObjectId( const DtGlobalObjectDesignator& drawObjectId );
   
   virtual double relativePosition() const;
   
   virtual void setRelativePosition( double relativePosition );
   
    virtual DtGlobalObjectDesignator entityId() const;
   
   virtual void setEntityId( const DtGlobalObjectDesignator& entityId );

   virtual bool isAttached() const;

   virtual const DtGlobalObjectDesignator& attachedId() const;

protected:

   DtVector myLocation;
   DtGlobalObjectDesignator myAttachedId;
   double myRelativePosition;
   
   DtSdc3DAttachmentType myAttachmentType;
};

class DL_DLL_IGCONVRLINK DtSdc3DPositionedObject : public DtSdcObject
{
public:
   DtSdc3DPositionedObject(DtExerciseConn* exConn, unsigned id,
      const DtString& objName);
   
   // \brief Virtual destructor
   virtual ~DtSdc3DPositionedObject();
  
private:
   DtSdc3DPositionedObject();

   DtSdc3DPositionedObject(const DtSdc3DPositionedObject& orig);

   DtSdc3DPositionedObject& operator=(const DtSdc3DPositionedObject& rhs);

public:
   virtual const DtSdc3DAttachPoint& attachment() const = 0;
   
   virtual void setAttachment(const DtSdc3DAttachPoint& attachment) = 0; 
};

class DL_DLL_IGCONVRLINK DtSdc3DTwoPositionedObject : public DtSdcObject
{
public:
   DtSdc3DTwoPositionedObject(DtExerciseConn* exConn, unsigned id,
      const DtString& objName);
   
   // \brief Virtual destructor
   virtual ~DtSdc3DTwoPositionedObject();
  
private:
   DtSdc3DTwoPositionedObject();

   DtSdc3DTwoPositionedObject(const DtSdc3DTwoPositionedObject& orig);

   DtSdc3DTwoPositionedObject& operator=(const DtSdc3DTwoPositionedObject& rhs);

public:
   virtual const DtSdc3DAttachPoint& startAttachment() const = 0;
   
   virtual void setStartAttachment(const DtSdc3DAttachPoint& attachment) = 0; 

   virtual const DtSdc3DAttachPoint& endAttachment() const = 0;
   
   virtual void setEndAttachment(const DtSdc3DAttachPoint& attachment) = 0; 
};



class DL_DLL_IGCONVRLINK DtSdcArea3DObject : public DtSdcObject
{
public:
   DtSdcArea3DObject(DtExerciseConn* exConn, unsigned id, std::vector<DtVector> vertices, 
      DtVector offset = DtVector::zero(),
      DtSdcColor color = DtSdcColor::DtSdcWhite, 
      const DtString& textureDirectory = "", 
      const DtString& textureFilename = DtString::nullString(),
      int numTextureTiles = 0, bool flashing = false);

   // \brief Virtual destructor
   virtual ~DtSdcArea3DObject();
  
private:
   DtSdcArea3DObject();

   DtSdcArea3DObject(const DtSdcArea3DObject& orig);

   DtSdcArea3DObject& operator=(const DtSdcArea3DObject& rhs);

public:
   virtual const DtVector& offset() const;

   virtual void setOffset(const DtVector& off);

   virtual const DtSdcColor& color() const;
 
   virtual void setColor (const DtSdcColor& color);

   virtual bool flashing() const;
   
   virtual void setFlashing(bool flashing);
      
   virtual const DtString& textureDirectory() const;

   virtual void setTextureDirectory(const DtString& str);

   virtual const DtString& textureFilename() const;

   virtual void setTextureFilename(const DtString& str);


   virtual int numTextureTiles() const;

   virtual void setNumTextureTiles(int numTextureTiles);

   virtual void update();

   virtual const DtVector& vertex(int index) const;
   //virtual DtVector& vertex();

   virtual void setVertex(int index, const DtVector& vertex);

   virtual void setRemoteGraphicSet(const std::string& setName);

protected:
   virtual void calculateBoundingSphere();
   virtual void setStateRecordUserData();
   void initRecords();

protected:
   DtVector myOffset;
   DtSdcColor myColor;
   bool myFlashing;
   int myNumVertices;
   std::vector<DtVector> myVertices;

   DtString myTextureFilename;
   DtString myTextureDirectory;
   int myNumTextureTiles;

   std::vector<DtEnvironmentalPointRecord> myPointRecords;
   DtEnvironmentalBoundingSphereRecord     myBoundingSphereRecord;
   Dt3DGraphicalObjectStateRecord          myStateRecord;

   DtVector myEmptyVertex;
};

/*
      DtSdc3DArea
*/

class DtSdcAttachablePduV0;

class DL_DLL_IGCONVRLINK DtSdcAttachablePdu : public DtStealthDrawControlPdu
{
public:
    
   typedef enum 
   {
      DtVcObjectNoAttach                  = 0, 
      DtVcObjectNoAttachNoAttach          = 1, 
      DtVcObjectAttachedToEntity          = 2, 
      DtVcObjectAttachedToObject          = 3, 
      DtVcObjectAttachedToEntityNoAttach  = 4, 
      DtVcObjectAttachedToObjectNoAttach  = 5, 
      DtVcObjectAttachedToNoAttachEntity  = 6, 
      DtVcObjectAttachedToNoAttachObject  = 7, 
      DtVcObjectAttachedToEntityObject    = 8, 
      DtVcObjectAttachedToObjectEntity    = 9, 
      DtVcObjectAttachedToEntityEntity    = 10,
      DtVcObjectAttachedToObjectObject    = 11 
   } DtVcObjectAttachment;

   typedef enum 
   {
      DtVcStyleNoFlashing        =0x00,
      DtVcStyleFlashing          =0x04,
      DtVcDrawingStyleEntry      =0x04
   } DtVcDrawingStyle;

   // 2 (line, cylinder) elements
   virtual const DtVcObjectAttachment attachmentType() const;

   // -100, -100 (lower left) to 100, 100 (upper right)
   virtual void attachTo(const DtNetInt8 pos[2]);

   virtual void attachTo(const DtNetInt8 pos1[2], const DtNetInt8 pos2[2]);

   virtual void attachTo(const DtVector &pos);
   virtual void attachTo(const DtNetU32 id);
   virtual void attachTo(const DtGlobalObjectDesignator& id);

   virtual void attachTo(const DtNetU32 id1, const DtNetU32 id2);
   virtual void attachTo(const DtGlobalObjectDesignator& id1, const DtGlobalObjectDesignator& id2);
   virtual void attachTo(const DtVector &pos1, const DtVector &pos2);
   virtual void attachTo(const DtGlobalObjectDesignator& id1, const DtNetU32 id2);
   virtual void attachTo(const DtNetU32 id1, const DtGlobalObjectDesignator& id2);
   virtual void attachTo(const DtGlobalObjectDesignator& id, const DtVector &pos);
   virtual void attachTo(const DtVector &pos, const DtGlobalObjectDesignator& id);
   virtual void attachTo(const DtNetU32 id, const DtVector &pos);
   virtual void attachTo(const DtVector &pos, const DtNetU32 id);

   virtual void setRelativeLocation(DtNetU8 percentage, int index=0);
   virtual const DtNetU8 relativeLocation(int index=0) const;
  
   virtual void setOffset(const DtVector &offsetVector);
   virtual DtVector offset() const;

   virtual const DtGlobalObjectDesignator attachEntityId(int index) const;
   virtual const DtNetU32 attachObjectId(int index) const;
   virtual DtVector position(int index) const;

   virtual void setColor(DtNetU8 color[4]);
   virtual const DtNetU8 *color() const;

   virtual void setFlashing(bool onOff);
   virtual const bool flashing() const;

   virtual void setFromString(const char *);
   virtual const char *string() const;

   virtual void printData() const;
   static const char *typeString(DtVcObjectAttachment param);

protected:

   
   // For internal use only.  AttachmentType is normally set autmatically
   // based on the form of attachTo() used.
   virtual void setAttachmentType( DtVcObjectAttachment attachmentType );
};
class DL_DLL_IGCONVRLINK DtSdcAttributeValue
{
public:
   DtSdcAttributeValue();

   ~DtSdcAttributeValue();

   DtSdcAttributeValue& operator=( const DtSdcAttributeValue& rhs );

   DtSdcAttributeValue( const DtSdcAttributeValue& orig );

   const DtString& textValue() const;
   void setTextValue( const DtString& textValue );

   double xValue() const;
   void setXValue( double x );

   double yValue() const;
   void setYValue( double y );

   bool dirty() const;
   void setDirty( bool dirty ) ;

   DtAttributeValueUpdate& attributeValueUpdate();
   const DtAttributeValueUpdate& attributeValueUpdate() const;

protected:
   DtString myTextValue;
   double myXValue;
   double myYValue;
   bool myDirty;
   DtAttributeValueUpdate myAttributeValueUpdate;
};


typedef std::map<DtString, DtSdcAttributeValue*> DtSdcAttributeValueMap;
class DtSdcAttributeGroupTemplateObject;

class DL_DLL_IGCONVRLINK DtSdcAttributeGroupObject : public DtSdcObject
{
public:
   DtSdcAttributeGroupObject(DtExerciseConn* exConn, unsigned id,  
      DtSdcAttributeGroupTemplateObject* pTemplate, 
      const DtSdc3DAttachPoint& attachment, 
      const DtVector& enuOffset = DtVector::zero(), 
      DtSdcColor color = DtSdcColor::DtSdcWhite, bool flashing = false);
   
   // \brief Virtual destructor
   virtual ~DtSdcAttributeGroupObject();
  
private:
   DtSdcAttributeGroupObject();

   DtSdcAttributeGroupObject(const DtSdcAttributeGroupObject& orig);

   DtSdcAttributeGroupObject& operator=(const DtSdcAttributeGroupObject& rhs);

   
public:
   virtual DtSdcAttributeGroupTemplateObject* attributeGroupTemplate() const;

   virtual const DtSdc3DAttachPoint& attachment() const;
   
   virtual void setAttachment(const DtSdc3DAttachPoint& attachment);
 
   virtual const DtVector& offset() const;
   
   virtual void setOffset(const DtVector& enuOffset);
   
   virtual const DtSdcColor& color() const;
   
   virtual void setColor (const DtSdcColor& color);
   
   virtual bool flashing() const;
   
   virtual void setFlashing(bool flashing);
   
   virtual DtString bmpAttributeValue(const DtString& attName) const;
   
   virtual void setBmpAttributeValue(const DtString& attName, const DtString& filename);
   
   virtual double numericAttributeValue(const DtString& attName) const;
   
   virtual void setNumericAttributeValue(const DtString& attName, double xVal);
   
   virtual double valueBarAttributeValue(const DtString& attName) const;
   
   virtual void setValueBarAttributeValue(const DtString& attName, double xVal);
   
   virtual double graphAttributeValueX(const DtString& attName) const;
   
   virtual void setGraphAttributeValueX(const DtString& attName, double xVal); 
   
   virtual double graphAttributeValueY(const DtString& attName) const;
   
   virtual void setGraphAttributeValueY(const DtString& attName, double yVal); 
  
   virtual DtSdcAttributeValueMap& attributeValueMap();
   
   virtual void setRemoteGraphicSet(const std::string& setName);

   virtual void update();
   
protected:
   virtual void createAttributes();
   virtual void destroyAttributes();
   virtual void copyAttributes(const DtSdcAttributeValueMap& valueMap);
   
protected:
   DtEnvironmentalPointRecord     myPointRecord;
   Dt3DGraphicalObjectStateRecord myGraphicObjectStateRecord;
   DtAttributeStateRecord         myAttributeStateRecord;

   DtSdc3DAttachPoint myAttachment;
   DtVector myEnuOffset;
   DtSdcColor myColor;
   bool myFlashing;
   DtSdcAttributeGroupTemplateObject* myAttributeGroupTemplate;
   DtSdcAttributeValueMap myValueMap;
};


class DL_DLL_IGCONVRLINK DtSdcAttributeTemplateObject
{
public:

   typedef enum 
   {
      DtSdcAttributeTypeNoValue = 0,
      DtSdcAttributeValueNumeric = 1,
      DtSdcAttributeTypeValueBar = 2,
      DtSdcAttributeTypeValueGraph = 3,
      DtSdcAttributeTypeBitmap = 4,
   } DtSdcAttributeType;

public:

   DtSdcAttributeTemplateObject(const DtGlobalObjectDesignator& templateId,
      const DtString& name, DtSdcAttributeType attributeType );

   // \brief Virtual destructor
   virtual ~DtSdcAttributeTemplateObject();

   DtSdcAttributeTemplateObject( 
      const DtSdcAttributeTemplateObject& orig );

   DtSdcAttributeTemplateObject& operator=( 
      const DtSdcAttributeTemplateObject& rhs );

private:
   DtSdcAttributeTemplateObject();

public:
   virtual const DtString& name() const;

   virtual const DtGlobalObjectDesignator& templateId() const;

   virtual DtSdcAttributeType attributeType() const;

   virtual const DtAttributeTemplateStateRecord& attributeTemplateRecord() const;

protected:
   DtGlobalObjectDesignator myTemplateId;
   DtString                 myName;
   DtSdcAttributeType       myAttributeType;
   DtAttributeTemplateStateRecord myAttributeTemplateRecord;
};

typedef std::list<DtSdcAttributeTemplateObject*> DtSdcAttributeTemplateList;

typedef std::map<DtString, DtSdcAttributeTemplateObject*> 
DtSdcAttributeTemplateMap;

class DL_DLL_IGCONVRLINK DtSdcAttributeGroupTemplateObject : public DtSdcObject
{
public:
   DtSdcAttributeGroupTemplateObject(DtExerciseConn* exConn, unsigned id,  
      const DtString& name);
   
   // \brief Virtual destructor
   virtual ~DtSdcAttributeGroupTemplateObject();
  
private:
   DtSdcAttributeGroupTemplateObject();

   DtSdcAttributeGroupTemplateObject(
      const DtSdcAttributeGroupTemplateObject& orig);

   DtSdcAttributeGroupTemplateObject& operator=(
      const DtSdcAttributeGroupTemplateObject& rhs);

public:
   virtual const DtString& name() const;
   
   virtual DtSdcAttributeTemplateObject* createAttributeTemplate(const DtString& name, 
      DtSdcAttributeTemplateObject::DtSdcAttributeType attType);
   
   virtual DtSdcAttributeTemplateObject* createAttributeTemplate(const DtString& name, 
      double minRange, double maxRange);
      
   virtual DtSdcAttributeTemplateList& attributeTemplates();
      
   virtual DtSdcAttributeTemplateObject* attributeTemplate(
      const DtString& name);
   
   virtual void update();
   
protected:
   DtString myName;
   DtSdcAttributeTemplateMap myAttributeTemplateMap;
   DtSdcAttributeTemplateList myAttributeTemplateList;
};

/*
   This Pdu creates an attribute, associated with an attribute group
      DtSdcAttributeGroup   
      DtSdcAttributeNoValue         
      DtSdcAttributeSingleValue     
      DtSdcAttributeGraphicSingleValue
      DtSdcAttributeListValue         
      DtSdcAttributeGraphicListValue  
      DtSdcAttributeBitmap      
      DtSdcAttributeGroupTemplate
*/

class DL_DLL_IGCONVRLINK DtSdcAttributePduBase : public DtSdcAttachablePdu
{
public:
   virtual void setName( DtString name );
   virtual const DtString name() const;

   virtual const DtNetU32 attributeGroupId() const;
   virtual void  setAttributeGroupId( DtNetU32 lid );

   virtual const bool hasRange() const;
   virtual const double rangeMin() const;
   virtual const double rangeMax() const;
   virtual void  setRange( double min, double max );

   virtual void setFromString( const char*str );
   virtual const char* string() const;

   virtual void printData() const;
};

class DL_DLL_IGCONVRLINK DtSdcAttributePdu : public DtSdcAttributePduBase
{
public: 
   DtSdcAttributePdu( DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
   DtSdcAttributePdu( const DtNetViewControlPdu* initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
};

class DL_DLL_IGCONVRLINK DtSdcAttributePduV0 : public DtSdcAttributePduBase
{
public:
   DtSdcAttributePduV0( DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
   DtSdcAttributePduV0( const DtNetViewControlPdu* initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
};

/*
   This Pdu sets a value for an Attribute
      DtSdcAttributeValueSet   
      DtSdcAttributeValueReset 
      DtSdcAttributeValueSetText
*/

class DL_DLL_IGCONVRLINK DtSdcAttributeUpdatePduBase : 
   public DtStealthDrawControlPdu
{
public:
   virtual void setText(DtString name);
   virtual const DtString text() const;

   virtual const DtNetU32 groupId() const;
   virtual void  setGroupId(DtNetU32 lid);

   virtual const double valueX() const;
   virtual const double valueY() const;
   virtual void  setValueX(double val);
   virtual void  setValueY(double val);

   virtual void setFromString(const char *str);
   virtual const char* string() const;

   virtual void printData() const;      
};

class DL_DLL_IGCONVRLINK DtSdcAttributeUpdatePdu : 
   public DtSdcAttributeUpdatePduBase
{
public:
   
   DtSdcAttributeUpdatePdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
   DtSdcAttributeUpdatePdu(const DtNetViewControlPdu *initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
};

class DL_DLL_IGCONVRLINK DtSdcAttributeUpdatePduV0 : 
   public DtSdcAttributeUpdatePduBase
{
public:
   
   DtSdcAttributeUpdatePduV0(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
   DtSdcAttributeUpdatePduV0(const DtNetViewControlPdu *initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
};

class DL_DLL_IGCONVRLINK DtSdcBarAttributeTemplateObject : 
   public DtSdcAttributeTemplateObject
{
public:
   DtSdcBarAttributeTemplateObject(
      const DtGlobalObjectDesignator& templateId,
      const DtString& name, double minRange, double maxRange);
   
   // \brief Virtual destructor
   virtual ~DtSdcBarAttributeTemplateObject();

   DtSdcBarAttributeTemplateObject( 
      const DtSdcBarAttributeTemplateObject& orig );

   DtSdcBarAttributeTemplateObject& operator=( 
      const DtSdcBarAttributeTemplateObject& rhs );

private:
   DtSdcBarAttributeTemplateObject();

public:
       
   virtual double minRange() const;

       
   virtual double maxRange() const;
  
protected:
   double myMinRange;
   double myMaxRange;

};

/*
   Use this pdu to send commands to other objects:
   The command are:

   DtVcRemove           remove the object with id objectId()
   DtVcHide             Hide an object and any object in it. i.e. If the receiver is a
                        layer, all objects in the layer will be affected.
   DtVcShow             Show an object and any object in it. i.e. If the receiver is a
                        layer, all objects in the layer will be affected.
   DtVcAddToLayer       Add the object to layer with id layerId()
   DtVcRemoveFromLayer  Remove the object from layer with id layerId()

   Use setType to specify the command you want to send.
*/

class DL_DLL_IGCONVRLINK DtSdcCommandPduBase : public DtStealthDrawControlPdu
{
public:      
   virtual const DtNetU32 layerId() const;
   virtual void  setLayerId( DtNetU32 lid );

   virtual void setFromString( const char *str );
   virtual const char* string() const;

   virtual void printData() const;
};


class DL_DLL_IGCONVRLINK DtSdcCommandPdu : public DtSdcCommandPduBase
{
public:
   DtSdcCommandPdu( DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
   DtSdcCommandPdu( const DtNetViewControlPdu* initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
};

class DL_DLL_IGCONVRLINK DtSdcCommandPduV0 : public DtSdcCommandPduBase
{
public:
   DtSdcCommandPduV0( DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
   DtSdcCommandPduV0( const DtNetViewControlPdu* initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
};

class DL_DLL_IGCONVRLINK DtSdcEllipsoidCuboidBase : public DtSdc3DPositionedObject
{
protected:
   DtSdcEllipsoidCuboidBase(DtExerciseConn* exConn, unsigned id, const DtString& objName,
      const DtSdc3DAttachPoint& attachment,const DtVector& dimensions, 
      const DtVector& enuOffset = DtVector::zero(),
      const DtTaitBryan& rotation = zeros, 
      DtSdcColor color = DtSdcColor::DtSdcWhite, bool flashing = false);

   // \brief Virtual destructor
   virtual ~DtSdcEllipsoidCuboidBase();

private:
   DtSdcEllipsoidCuboidBase();

   DtSdcEllipsoidCuboidBase(const DtSdcEllipsoidCuboidBase& orig);

   DtSdcEllipsoidCuboidBase& operator=(const DtSdcEllipsoidCuboidBase& rhs);

public:

   virtual const DtSdc3DAttachPoint& attachment() const;   

   virtual void setAttachment(const DtSdc3DAttachPoint& attachment);

   virtual const DtVector& offset() const;

   virtual void setOffset(const DtVector& off);
   virtual const DtTaitBryan& rotation() const;

   virtual void setRotation(const DtTaitBryan& rotation);

   virtual const DtSdcColor& color() const;

   virtual void setColor (const DtSdcColor& color);

   virtual bool flashing() const;

   virtual void setFlashing(bool flashing);

   virtual void setRemoteGraphicSet(const std::string& setName);


private:
   void initRecords();
   // Initializer for DtTaitBryan
   static DtTaitBryan zeros;

protected:
   DtSdc3DAttachPoint             myAttachment;
   DtVector                       myDimensions;
   DtVector                       myOffset;
   DtSdcColor                     myColor;
   DtTaitBryan                    myRotation;
   bool                           myFlashing;
   Dt3DGraphicalObjectStateRecord myStateRecord;
};



class DL_DLL_IGCONVRLINK DtSdcCuboidObject : public DtSdcEllipsoidCuboidBase
{
public:
   DtSdcCuboidObject(DtExerciseConn* exConn, unsigned id, const DtSdc3DAttachPoint& attachment,
      double length, double width, double height, 
      const DtVector& enuOffset = DtVector::zero(),
      const DtTaitBryan& rotation = zeros, 
      DtSdcColor color = DtSdcColor::DtSdcWhite, bool flashing = false);
   
   // \brief Virtual destructor
   virtual ~DtSdcCuboidObject();
 
   virtual double length() const;
   
   virtual void setLength(double length);
      
   virtual double width() const;
   
   virtual void setWidth(double width);
      
   virtual double height() const;
   
   virtual void setHeight(double height);

   virtual void setAttachment(const DtSdc3DAttachPoint& attachment);
   virtual void setRotation(const DtTaitBryan& rotation);

   virtual void update();
     
private:
   DtSdcCuboidObject();

   DtSdcCuboidObject(const DtSdcCuboidObject& orig);

   DtSdcCuboidObject& operator=(const DtSdcCuboidObject& rhs);

   void initCuboidRecords();

protected:
   DtEnvironmentalRectangularVolumeRecord myCuboidRecord;

private:
   // Initializer for DtTaitBryan
   static DtTaitBryan zeros;
 
};

class DL_DLL_IGCONVRLINK DtSdcCylinderObject : public DtSdc3DTwoPositionedObject
{
public:
   
   
   DtSdcCylinderObject(DtExerciseConn* exConn, unsigned id, 
      const DtSdc3DAttachPoint& attachment, double length, 
      const DtSdcVector2D& diameters, const DtVector& offset = DtVector::zero(),
      const DtTaitBryan& rotation = zeros, 
      DtSdcColor color = DtSdcColor::DtSdcWhite, bool flashing = false);
      
   DtSdcCylinderObject(DtExerciseConn* exConn, unsigned id, 
   const DtSdc3DAttachPoint& startAttachment,
      const DtSdc3DAttachPoint& endAttachment, 
      const DtSdcVector2D& diameters, 
      const DtVector& offset = DtVector::zero(),
      DtSdcColor color = DtSdcColor::DtSdcWhite, bool flashing = false );
   
   // \brief Virtual destructor
   virtual ~DtSdcCylinderObject();
  
private:
   DtSdcCylinderObject();

   DtSdcCylinderObject(const DtSdcCylinderObject& orig);

   DtSdcCylinderObject& operator=(const DtSdcCylinderObject& rhs);

public:
   virtual const DtSdc3DAttachPoint& attachment() const;   
   
   virtual void setAttachment(const DtSdc3DAttachPoint& attachment);

   virtual const DtSdc3DAttachPoint& startAttachment() const;   
   
   virtual void setStartAttachment(const DtSdc3DAttachPoint& startAttachment);

   virtual const DtSdc3DAttachPoint& endAttachment() const;   
   
   virtual void setEndAttachment(const DtSdc3DAttachPoint& endAttachment);
 
   virtual const DtVector& offset() const;
   
   virtual void setOffset(const DtVector& off);
 
   virtual double length() const;
  
   virtual void setLength(double length);
  
   virtual const DtSdcVector2D& diameters() const;
   
   virtual void setDiameters(const DtSdcVector2D& diameters);
     
   virtual const DtTaitBryan& rotation() const;
   
   virtual void setRotation(const DtTaitBryan& rotation);
 
   virtual const DtSdcColor& color() const;
   
   virtual void setColor (const DtSdcColor& color);

   virtual bool flashing() const;
   
   virtual void setFlashing(bool flashing);
      
   virtual void setRemoteGraphicSet(const std::string& setName);

   virtual void update();
   
protected:
   void initRecords();

private:
   // Initializer for DtTaitBryan
   static DtTaitBryan zeros;
   
protected:
   DtSdc3DAttachPoint myStartAttachment; // also single attachment
   DtSdc3DAttachPoint myEndAttachment;
   double myLength;
   DtSdcVector2D myDiameters;
   DtVector myOffset;
   DtSdcColor myColor;
   DtTaitBryan myRotation;
   bool myFlashing;

   Dt3DGraphicalObjectStateRecord myStateRecord;
   DtEnvironmentalFixedCylinderRecord myFixedCylinderRecord;
   DtEnvironmentalArticulatingCylinderRecord myArticulatingCylinderRecord;
};

class DL_DLL_IGCONVRLINK DtSdcEllRectBase : public DtSdc2DPositionedObject
{
protected:
   DtSdcEllRectBase(DtExerciseConn* exConn, unsigned id, const DtString& objName,
      const DtSdcVector2D& position, const DtSdcVector2D& size, 
      double rotation = 0.0, double scale = 1.0, 
      DtSdcColor color = DtSdcColor::DtSdcWhite, bool fill = false, 
      unsigned pattern = 0xffffffff, bool flashing = false);
   /*
   DtSdcEllRectBase( const DtSdcEllRectBase& orig );
   
   DtSdcEllRectBase& operator=( const DtSdcEllRectBase& rhs );
   */
   // \brief Virtual destructor
   virtual ~DtSdcEllRectBase();
  
private:
   DtSdcEllRectBase();
   
public:
   virtual DtSdcVector2D position() const;
   
   virtual void setPosition( const DtSdcVector2D& position );
 
   virtual DtSdcVector2D size() const;
   
   virtual void setSize( const DtSdcVector2D& size );
     
   virtual double rotation() const;
   
   virtual void setRotation( double rotation );
 
   virtual const DtSdcColor& color() const;
   
   virtual void setColor (const DtSdcColor& color );
   
   virtual bool fill() const;
   
   virtual void setFill( bool fill );
   
   virtual unsigned pattern() const;
   
   virtual void setPattern( unsigned pattern );
   
   virtual bool flashing() const;
   
   virtual void setFlashing( bool flashing );

   virtual double scale() const;

   virtual void setScale( double scale );
      
   virtual void setRemoteGraphicSet(const std::string& setName);

   virtual void update();
   
protected:
   DtSdcVector2D myPosition;
   DtSdcVector2D mySize;
   DtSdcColor myColor;
   unsigned myPattern;
   bool myFill;
   double myRotation;
   bool myFlashing;
   double myScale;
   
   Dt2DGraphicalObjectStateRecord* myStateRecord;
};


class DL_DLL_IGCONVRLINK DtSdcEllipseObject : public DtSdcEllRectBase
{
public:
   DtSdcEllipseObject(DtExerciseConn* exConn, unsigned id, const DtSdcVector2D& position,
      const DtSdcVector2D& size, double rotation = 0.0, double scale = 1.0,
      DtSdcColor color = DtSdcColor::DtSdcWhite, bool fill = false, 
      unsigned pattern = 0xffffffff, bool flashing = false  );
   /*
   DtSdcEllipseObject( const DtSdcEllipseObject& orig );
   
   DtSdcEllipseObject& operator=( const DtSdcEllipseObject& rhs );
   */
   
   // \brief Virtual destructor
   virtual ~DtSdcEllipseObject();
  
private:
   DtSdcEllipseObject();

};

class DL_DLL_IGCONVRLINK DtSdcEllipsoidObject : public 
   DtSdcEllipsoidCuboidBase
{
public:
   DtSdcEllipsoidObject(DtExerciseConn* exConn, unsigned id, const DtSdc3DAttachPoint& attachment,
      const DtVector& diameters, const DtVector& enuOffset = DtVector::zero(),
      const DtTaitBryan& rotation = zeros, 
      DtSdcColor color = DtSdcColor::DtSdcWhite, bool flashing = false);
   
   // \brief Virtual destructor
   virtual ~DtSdcEllipsoidObject();

 
   virtual const DtVector& diameters() const;
   
   virtual void setDiameters(const DtVector& diameters);

   virtual void setAttachment(const DtSdc3DAttachPoint& attachment);
   virtual void setRotation(const DtTaitBryan& rotation);

   virtual void update();

protected:
   DtEnvironmentalEllipsoidRecord myEllipsoidRecord;
     

private:
   DtSdcEllipsoidObject();

   DtSdcEllipsoidObject(const DtSdcEllipsoidObject& orig);

   DtSdcEllipsoidObject& operator=(const DtSdcEllipsoidObject& rhs);

   void initEllipsoidRecords();

private:
   // Initializer for DtTaitBryan
   static DtTaitBryan zeros;
 
};

/*
   This Pdu creates a new layer with name name() and id objectId().
   If the object already exists, it replaces the old one and if the object
   is a layer, it clean up the layer (remove all objects from the layer)
*/
class DL_DLL_IGCONVRLINK DtSdcLayerPduBase : public DtStealthDrawControlPdu
{
public:    
   virtual void setName(DtString name);
   virtual const DtString name() const;

   virtual void setFromString(const char *str);
   virtual const char *string() const;

   virtual void printData() const;
};

class DL_DLL_IGCONVRLINK DtSdcLayerPdu : public DtSdcLayerPduBase
{
public:    
   DtSdcLayerPdu(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
   DtSdcLayerPdu(const DtNetViewControlPdu *initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
};
class DL_DLL_IGCONVRLINK DtSdcLayerPduV0 : public DtSdcLayerPduBase
{
public:
    
   DtSdcLayerPduV0(DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);
   DtSdcLayerPduV0(const DtNetViewControlPdu *initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER);

};

class DL_DLL_IGCONVRLINK DtSdcLineSegment
{
public:
   typedef enum 
   {
      DtSdcSegmentStyleStraight,
      DtSdcSegmentStyleLightning
   } DtSdcSegmentStyle;

   typedef enum 
   {
      DtSdcSegmentArrowStyleNoArrow,
      DtSdcSegmentArrowStyleArrowEnd,
      DtSdcSegmentArrowStyleArrowStart,
      DtSdcSegmentArrowStyleArrowDouble
   } DtSdcSegmentArrowStyle;

public:
   DtSdcLineSegment(double percentage, DtSdcColor color, unsigned pattern, 
      unsigned thickness, DtSdcSegmentStyle style, 
      DtSdcSegmentArrowStyle arrowStyle);

   DtSdcLineSegment();

   DtSdcLineSegment( const DtSdcLineSegment& orig );

   DtSdcLineSegment operator=( const DtSdcLineSegment& orig );

   const DtSdcColor& color() const;
   void setColor( const DtSdcColor& color );

   unsigned pattern() const;
   void setPattern( unsigned pattern );

   unsigned thickness() const;
   void setThickness( unsigned thickness );

   double percentage() const;
   void setPercentage ( double percentage );

   DtSdcSegmentStyle style() const;
   void setStyle( DtSdcSegmentStyle style );

   DtSdcSegmentArrowStyle arrowStyle() const;
   void setArrowStyle( DtSdcSegmentArrowStyle arrowStyle );

protected:
   DtSdcColor myColor;
   unsigned myPattern;
   unsigned myThickness;
   double myPercentage;
   DtSdcSegmentStyle myStyle;
   DtSdcSegmentArrowStyle myArrowStyle;
};

class DL_DLL_IGCONVRLINK DtSdcLineObjectInterface 
{
public:
   virtual int numSegments() const = 0;

   virtual void setNumSegments(int numSegments) = 0;

   virtual DtSdcLineSegment::DtSdcSegmentStyle lineStyle(int segment=0) const = 0;

   virtual void setLineStyle(DtSdcLineSegment::DtSdcSegmentStyle lineStyle,
      int segment=0) = 0;

   virtual DtSdcLineSegment::DtSdcSegmentArrowStyle arrowStyle(int segment=0)
      const = 0;

   virtual void setArrowStyle(DtSdcLineSegment::DtSdcSegmentArrowStyle arrowStyle,
      int segment=0) = 0;

   virtual unsigned pattern(int segment=0) const = 0;

   virtual void setPattern(unsigned pattern, int segment=0) = 0;

   virtual unsigned thickness(int segment=0) const = 0;

   virtual void setThickness(unsigned thickness, int segment=0) = 0;

   virtual double percentage(int segment) const = 0;

   virtual void setPercentage(double percentage, int segment) = 0;
};


class DL_DLL_IGCONVRLINK DtSdcLine2DObject : public DtSdcObject, public DtSdcLineObjectInterface
{
public:
   DtSdcLine2DObject( DtExerciseConn* exConn, unsigned id, const DtSdcVector2D& startPosition, 
      const DtSdcVector2D& endPosition, int numSegments=1, 
      DtSdcColor color = DtSdcColor::DtSdcWhite, 
      DtSdcLineSegment::DtSdcSegmentStyle lineStyle = 
         DtSdcLineSegment::DtSdcSegmentStyleStraight,
      DtSdcLineSegment::DtSdcSegmentArrowStyle arrowStyle = 
         DtSdcLineSegment::DtSdcSegmentArrowStyleNoArrow, 
      unsigned thickness=1, unsigned pattern=0xffffff, bool flashing = false  );
   
   // \brief Virtual destructor
   virtual ~DtSdcLine2DObject();
  
private:
   DtSdcLine2DObject();
   
public:
   virtual DtSdcVector2D startPosition() const;
   
   virtual void setStartPosition( const DtSdcVector2D& startPosition );

   virtual DtSdcVector2D endPosition() const;
   
   virtual void setEndPosition( const DtSdcVector2D& endPosition );

   virtual int numSegments() const;
   
   virtual void setNumSegments( int numSegments );

   virtual const DtSdcColor& color( int segment ) const;
   virtual const DtSdcColor& color() const;
   
   virtual void setColor ( const DtSdcColor& color, int segment );
   virtual void setColor ( const DtSdcColor& color);

   virtual DtSdcLineSegment::DtSdcSegmentStyle lineStyle( int segment=0 ) const;
   
   virtual void setLineStyle( DtSdcLineSegment::DtSdcSegmentStyle lineStyle,
      int segment=0 );

   virtual DtSdcLineSegment::DtSdcSegmentArrowStyle arrowStyle( int segment=0 )
       const;
       
   virtual void setArrowStyle( DtSdcLineSegment::DtSdcSegmentArrowStyle arrowStyle,
      int segment=0 );
   
   virtual unsigned pattern( int segment=0 ) const;
   
   virtual void setPattern( unsigned pattern, int segment=0 );
   
   virtual unsigned thickness( int segment=0 ) const;
   
   virtual void setThickness( unsigned thickness, int segment=0 );
   
   virtual double percentage( int segment ) const;
   
   virtual void setPercentage( double percentage, int segment );

   virtual bool flashing() const;
   
   virtual void setFlashing( bool flashing );

   virtual void setRemoteGraphicSet(const std::string& setName);

      
   virtual void update();
   
protected:
   virtual void initRecords();

   DtSdcVector2D                 myStartPosition;
   DtSdcVector2D                 myEndPosition;
   bool                          myFlashing;
   std::vector<DtSdcLineSegment> myLineSegments;

   DtEnvironmentalLineRecord          myLineRecord;
   Dt3DGraphicalObjectLineStateRecord myLineStateRecord;
};

class DL_DLL_IGCONVRLINK DtSdcLine3DObject : public DtSdc3DTwoPositionedObject, 
   public DtSdcLineObjectInterface
{
public:
   DtSdcLine3DObject(DtExerciseConn* exConn, unsigned id, const DtSdc3DAttachPoint& startAttachment, 
      const DtSdc3DAttachPoint& endAttachment, int numSegments=1, 
      const DtVector& offset = DtVector::zero(), 
      DtSdcColor color = DtSdcColor::DtSdcWhite, 
      DtSdcLineSegment::DtSdcSegmentStyle lineStyle = 
         DtSdcLineSegment::DtSdcSegmentStyleStraight,
      DtSdcLineSegment::DtSdcSegmentArrowStyle arrowStyle = 
         DtSdcLineSegment::DtSdcSegmentArrowStyleNoArrow, 
      unsigned thickness=1, unsigned pattern=0xffffff, bool flashing = false,
      bool checkLos = false, bool projected = false);
   
  
   virtual ~DtSdcLine3DObject();
  
private:
   DtSdcLine3DObject();

   DtSdcLine3DObject(const DtSdcLine3DObject& orig);

   DtSdcLine3DObject& operator=(const DtSdcLine3DObject& rhs);

   
public:
   virtual const DtSdc3DAttachPoint& startAttachment() const;
   
   virtual void setStartAttachment(const DtSdc3DAttachPoint& startAttachment);

   virtual const DtSdc3DAttachPoint& endAttachment() const;
   
   virtual void setEndAttachment(const DtSdc3DAttachPoint& endAttachment);

   virtual const DtVector& offset() const;
   
   virtual void setOffset(const DtVector& off);

   virtual int numSegments() const;
   
   virtual void setNumSegments(int numSegments);

   virtual const DtSdcColor& color(int segment) const;
   virtual const DtSdcColor& color() const;
   
   virtual void setColor (const DtSdcColor& color, int segment);
   virtual void setColor (const DtSdcColor& color);

   virtual DtSdcLineSegment::DtSdcSegmentStyle lineStyle(int segment=0) const;
   
   virtual void setLineStyle(DtSdcLineSegment::DtSdcSegmentStyle lineStyle,
      int segment=0);

   virtual DtSdcLineSegment::DtSdcSegmentArrowStyle arrowStyle(int segment=0)
       const;
       
   virtual void setArrowStyle(DtSdcLineSegment::DtSdcSegmentArrowStyle arrowStyle,
      int segment=0);
   
   virtual unsigned pattern(int segment=0) const;
   
   virtual void setPattern(unsigned pattern, int segment=0);
   
   virtual unsigned thickness(int segment=0) const;
   
   virtual void setThickness(unsigned thickness, int segment=0);
   
   virtual double percentage(int segment) const;
   
   virtual void setPercentage(double percentage, int segment);

   virtual bool flashing() const;
   
   virtual void setFlashing(bool flashing);
 
   virtual bool checkLos() const;
   
   virtual void setCheckLos(bool checkLos);
 
   virtual bool projected() const;
   
   virtual void setProjected (bool projected );

   virtual void setRemoteGraphicSet(const std::string& setName);

   virtual void update();
 
protected:
   void initRecords();

protected:
   DtSdc3DAttachPoint            myStartAttachment;
   DtSdc3DAttachPoint            myEndAttachment;
   DtVector                      myOffset;
   bool                          myFlashing;
   bool                          myCheckLos;
   bool                          myProjected;
   std::vector<DtSdcLineSegment> myLineSegments;

   DtEnvironmentalLineRecord          myLineRecord;
   Dt3DGraphicalObjectLineStateRecord myLineStateRecord;
};


/*
  2DLine
  3DLine
  2DSegmentedLine (for back compatibility)
  3DSegmentedLine (for back compatibility)
*/
class DL_DLL_IGCONVRLINK DtSdcLinePdu : public DtSdcAttachablePdu
{
public:
   using DtSdcAttachablePdu::typeString;

public:
   typedef enum 
   {
      DtSdcStyleNoArrow        =0x00,
      DtSdcStyleArrowEnd       =0x01,
      DtSdcStyleArrowStart     =0x02,
      DtSdcStyleArrowDouble    =0x03,
      DtSdcLineArrowStyleEntry =0x03
   } DtSdcLineArrowStyle;

   typedef enum 
   {
      DtSdcLineAppearanceStraight     =0x00,
      DtSdcLineAppearanceLightning   =0x08,
      DtSdcLineAppearanceEntry       =0x08
   } DtSdcLineAppearance;

public:   
    
   DtSdcLinePdu( DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
   DtSdcLinePdu( const DtNetViewControlPdu* initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
      
   // Trick to prevent default constructor being called; used
   // by DtSdcLinePduV0 and DtSdcSegmentedLinePduV0
   DtSdcLinePdu( double doNothing );

   virtual void setNumSegments( DtNetU8 segments );
   virtual const DtNetU8 numSegments() const;

   virtual void setArrowStyle( DtSdcLineArrowStyle style );   
   virtual void setArrowStyle( unsigned int segment, DtSdcLineArrowStyle style );  
   virtual const DtSdcLineArrowStyle arrowStyle( unsigned int segment=0 ) const;

   virtual void setAppearance( DtSdcLineAppearance app );
   virtual void setAppearance( unsigned int segment, DtSdcLineAppearance app );
   virtual const DtSdcLineAppearance appearance( unsigned int segment=0 ) const;

   virtual void setThickness( DtNetU8 thickness );
   virtual void setThickness( unsigned int segment, DtNetU8 thickness );
   virtual const DtNetU8 thickness( unsigned int segment=0 ) const;

   virtual void setPattern( DtNetU32 patt );
   virtual void setPattern( unsigned int segment, DtNetU32 patt );
   virtual const DtNetU32 pattern( unsigned int segment=0 ) const;

   virtual void setColor( DtNetU8 color[4] );
   virtual void setColor( unsigned int segment, DtNetU8 color[4] );
   
   virtual const DtNetU8* color() const;
   virtual const DtNetU8* color( unsigned int segment ) const;
   
   virtual void setPercentage( unsigned int segment, DtNetU8 percent );
   virtual const DtNetU8 percentage( unsigned int segment=0 ) const;
   
   virtual void setCheckLos( bool checkLos );
   virtual bool checkLos() const;
   
   virtual void setProjected( bool projected );
   virtual bool projected() const;

   virtual void printData() const;

protected:
   virtual const char* typeString( DtSdcLinePdu::DtSdcLineArrowStyle param ) const;
   virtual const char* typeString( DtSdcLinePdu::DtSdcLineAppearance param ) const;
};

class DL_DLL_IGCONVRLINK DtSdcLinePduV0 : public DtSdcLinePdu
{
public:
    
   DtSdcLinePduV0( DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
   DtSdcLinePduV0( const DtNetViewControlPdu* initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
};

class DL_DLL_IGCONVRLINK DtSdcSegmentedLinePduV0 : public DtSdcLinePdu
{
public:
    
   DtSdcSegmentedLinePduV0( DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
   DtSdcSegmentedLinePduV0( const DtNetViewControlPdu* initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
};

/*
      DtSdcCircle
      DtSdcSphere 
      DtSdcSquare 
      DtSdcCube 
      DtSdcCylinder  
*/

class DL_DLL_IGCONVRLINK DtSdcPolyObjectPduBase : public DtSdcAttachablePdu
{
public:
    
   typedef enum 
   {
      DtSdcFillAreaOff     =0x00,
      DtSdcFillAreaOn      =0x40,
      DtSdcFillAreaEntry   =0x40
   } DtSdcFillArea;

public:
   virtual void setFill( bool onOff ) const;
   virtual bool fill() const;

   virtual void setPattern( DtNetU32 patt );
   virtual const DtNetU32 pattern() const;

   virtual void setScale( const DtVector &pos );
   virtual DtVector scale() const;

   virtual void setRotation( const DtTaitBryan &tait );
   virtual DtTaitBryan rotation() const;

   virtual void setFromString( const char* str );
   virtual const char* string() const;

   virtual void printData() const;

};

class DL_DLL_IGCONVRLINK DtSdcPolyObjectPdu : public DtSdcPolyObjectPduBase
{
public:
   DtSdcPolyObjectPdu( DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
   DtSdcPolyObjectPdu( const DtNetViewControlPdu* initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
};

class DL_DLL_IGCONVRLINK DtSdcPolyObjectPduV0 : public DtSdcPolyObjectPduBase
{
public:
   DtSdcPolyObjectPduV0( DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
   DtSdcPolyObjectPduV0( const DtNetViewControlPdu* initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
};

class DL_DLL_IGCONVRLINK DtSdcRectangleObject : public DtSdcEllRectBase
{
public:
   DtSdcRectangleObject(DtExerciseConn* exConn, unsigned id, const DtSdcVector2D& position,
      const DtSdcVector2D& size, double rotation = 0.0, double scale = 1.0,
      DtSdcColor color = DtSdcColor::DtSdcWhite, bool fill = false, 
      unsigned pattern = 0xffffffff, bool flashing = false  );

   // \brief Virtual destructor
   virtual ~DtSdcRectangleObject();
  
private:
   DtSdcRectangleObject();

};

class DtExerciseConn;
class DtStealthDrawControlPdu;
class DtCustomRemoteControlSender;

typedef std::map<unsigned, DtSdcObject*> DtSdcObjectList;

#if DtDIS
   class DtInetSocket;
#endif

class DL_DLL_IGCONVRLINK DtStealthRemoteDrawer
{
public:
   DtStealthRemoteDrawer(DtExerciseConn* exConn, 
      const DtGlobalObjectDesignator& targetStealthId = SEND_TO_ALL, 
      unsigned nextId = 0);  
       
   DtStealthRemoteDrawer(DtCustomRemoteControlSender* sender, 
     const DtGlobalObjectDesignator& senderId,
     const DtGlobalObjectDesignator& targetStealthId = SEND_TO_ALL, 
      unsigned nextId = 0);  

#if DtHLA























   DtStealthRemoteDrawer(const char* execName, const char* federateType,
      DtFomMapper* mapper = DtRprFomMapper::create(NULL),
      const char* fedFileName = NULL,
      const DtGlobalObjectDesignator& targetStealthId = SEND_TO_ALL, 
      unsigned nextId = 0);

   DtStealthRemoteDrawer(const char* execName, const char* federateType,
      const char* dsoName, const char* fedFileName = NULL,
      void* fomMapInitData = NULL,
      const DtGlobalObjectDesignator& targetStealthId = SEND_TO_ALL, 
      unsigned nextId = 0);
#endif

#if DtDIS


















  DtStealthRemoteDrawer(int port, int exerciseId,
      int siteId, int applicationNum,
      const DtGlobalObjectDesignator& targetStealthId = SEND_TO_ALL, 
      unsigned nextId = 0);

  DtStealthRemoteDrawer(int port, const DtInetAddr& destAddr, int exerciseId,
      int siteId, int applicationNum,
      const DtGlobalObjectDesignator& targetStealthId = SEND_TO_ALL, 
      unsigned nextId = 0);

  DtStealthRemoteDrawer(DtInetSocket *skt, int exerciseId,
      int siteId, int applicationNum,
      const DtGlobalObjectDesignator& targetStealthId = SEND_TO_ALL, 
      unsigned nextId = 0);
#endif
   
private:
   DtStealthRemoteDrawer();
   
   DtStealthRemoteDrawer(const DtStealthRemoteDrawer&);
   
   DtStealthRemoteDrawer& operator=(const DtStealthRemoteDrawer&);
   
public:
   virtual ~DtStealthRemoteDrawer();

public:      

   virtual unsigned nextId();

   virtual void add(DtSdcObject* object);

   virtual void addToLayer(unsigned id, unsigned layerId);
 
   
   virtual DtSdcObject* remove(unsigned id);
  
   virtual void removeFromLayer(unsigned id, unsigned layerId );
  
   virtual DtSdcObject* lookup(unsigned id);
 
   virtual void update(unsigned id);
   
   virtual void show(unsigned id);

   virtual void showAttribute(unsigned groupId, unsigned attributeId);
  
   virtual void hide(unsigned id);

   virtual void hideAttribute(unsigned groupId, unsigned attributeId);

public:
   static const DtGlobalObjectDesignator SEND_TO_ALL;

protected:
   virtual void update(DtSdcObject* object);

   
protected:
   DtExerciseConn* myExConn;
   DtCustomRemoteControlSender* myCustomSender;
   
   unsigned myNextId;
   DtSdcObjectList myObjectList;
   bool myCreatedExConn;
   DtGlobalObjectDesignator myTargetId;
   DtGlobalObjectDesignator mySenderId;
   
#if DtHLA
   DtStealthControlInteraction mySendInter;
#endif

};

class DL_DLL_IGCONVRLINK DtSdcText2DObject : public DtSdcObject
{
public:
   DtSdcText2DObject(DtExerciseConn* exConn,  unsigned id,  const DtString& text, 
      const DtSdcVector2D& position, DtSdcColor color = DtSdcColor::DtSdcWhite, 
       bool flashing = false  );
   
   // \brief Virtual destructor
   virtual ~DtSdcText2DObject();
  
private:
   DtSdcText2DObject();
   
public:
   virtual DtString text() const;
   
   virtual void setText( const DtString& text );

   virtual DtSdcVector2D position() const;
   
   virtual void setPosition( const DtSdcVector2D& position );
 
   virtual const DtSdcColor& color() const;
   
   virtual void setColor (const DtSdcColor& color );
   
   virtual bool flashing() const;
   
   virtual void setFlashing( bool flashing );

   virtual void setFont(const char* fontFile, float size);

   virtual void setRemoteGraphicSet(const std::string& setName);

   virtual void update();
   
protected:
   DtSdcVector2D myPosition;
   DtSdcColor myColor;
   bool myFlashing;
   DtString myText;
   
   Dt2DGraphicalObjectTextStateRecord* myStateRecord;
};

class DL_DLL_IGCONVRLINK DtSdcText3DObject : public DtSdc3DPositionedObject
{
public:
   DtSdcText3DObject(DtExerciseConn* exConn, unsigned id,  const DtString& text, 
      const DtSdc3DAttachPoint& attachment, 
      const DtVector& enuOffset = DtVector::zero(), 
      DtSdcColor color = DtSdcColor::DtSdcWhite, bool flashing = false);
   
   // \brief Virtual destructor
   virtual ~DtSdcText3DObject();
  
private:
   DtSdcText3DObject();

   DtSdcText3DObject(const DtSdcText3DObject& orig);

   DtSdcText3DObject& operator=(const DtSdcText3DObject& rhs);

public:
   virtual const DtString& text() const;
   
   virtual void setText(const DtString& text);

   virtual const DtSdc3DAttachPoint& attachment() const;
   
   virtual void setAttachment(const DtSdc3DAttachPoint& attachment);
 
   virtual const DtVector& offset() const;

   virtual void setOffset(const DtVector& off);
   
   virtual const DtSdcColor& color() const;
   
   virtual void setColor (const DtSdcColor& color);
   
   virtual bool flashing() const;
   
   virtual void setFlashing(bool flashing);
      
   virtual void setRemoteGraphicSet(const std::string& setName);

   virtual void update();

protected:
   void initRecords();

protected:
   DtSdc3DAttachPoint myAttachment;
   DtVector myOffset;
   DtSdcColor myColor;
   bool myFlashing;
   DtString myText;

   DtEnvironmentalPointRecord     myPointRecord;
   Dt3DGraphicalObjectStateRecord myStateRecord;
};

/*
   Use this pdu to send 2DText and 3DText:
   type:

   DtSdc2DText           place the text on the overlay.
   DtSdc3DText           place the text on the scene.
   Use setType to specify the command you want to send.
*/
class DL_DLL_IGCONVRLINK DtSdcTextPduBase : public DtSdcAttachablePdu
{
public:
   virtual void setText( DtString s );
   virtual const DtString text() const;

   virtual void setFromString( const char* );
   virtual const char* string() const;

   virtual void printData() const;
};


class DL_DLL_IGCONVRLINK DtSdcTextPdu : public DtSdcTextPduBase
{
public:
   DtSdcTextPdu( DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
   DtSdcTextPdu( const DtNetViewControlPdu* initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
};

class DL_DLL_IGCONVRLINK DtSdcTextPduV0 : public DtSdcTextPduBase
{
public:
   DtSdcTextPduV0( DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
   DtSdcTextPduV0( const DtNetViewControlPdu* initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
};

class DL_DLL_IGCONVRLINK DtSdcTriangle2DObject : public DtSdcObject
{
public:
   DtSdcTriangle2DObject(DtExerciseConn* exConn, unsigned id, const DtSdcVector2D& vertex1, 
      const DtSdcVector2D& vertex2, const DtSdcVector2D& vertex3, 
      const DtSdcVector2D& offset = DtSdcVector2D::zero(), 
      const DtSdcVector2D& scale= DtSdcVector2D::ones(), 
      double rotation = 0.0, DtSdcColor color = DtSdcColor::DtSdcWhite, 
      bool fill = false, unsigned pattern = 0xffffffff, bool flashing = false  );
   
   DtSdcTriangle2DObject( const DtSdcTriangle2DObject& orig );
   
   DtSdcTriangle2DObject& operator=( const DtSdcTriangle2DObject& rhs );
   
   // \brief Virtual destructor
   virtual ~DtSdcTriangle2DObject();
  
private:
   DtSdcTriangle2DObject();
   
public:
   virtual DtSdcVector2D vertex1() const;
   
   virtual void setVertex1( const DtSdcVector2D& vertex );
   
   virtual DtSdcVector2D vertex2() const;
   
   virtual void setVertex2( const DtSdcVector2D& vertex );
 
   virtual DtSdcVector2D vertex3() const;
   
   virtual void setVertex3( const DtSdcVector2D& vertex );

   virtual DtSdcVector2D offset() const;
   
   virtual void setOffset( const DtSdcVector2D& offset );
   
   virtual DtSdcVector2D scale() const;
   
   virtual void setScale( const DtSdcVector2D& scale );
      
   virtual double rotation() const;
   
   virtual void setRotation( double rotation );
 
   virtual const DtSdcColor& color() const;
   
   virtual void setColor (const DtSdcColor& color );
   
   virtual bool fill() const;
   
   virtual void setFill( bool fill );
   
   virtual unsigned pattern() const;
   
   virtual void setPattern( unsigned pattern );
   
   virtual bool flashing() const;
   
   virtual void setFlashing( bool flashing );

   virtual void setRemoteGraphicSet(const std::string& setName);

   virtual void update();

protected:
   
   virtual DtSdcVector2D transformVertex(const DtSdcVector2D& v, const DtSdcVector2D& center) const;
   virtual void transformVertices();

   DtSdcVector2D myVertex1;
   DtSdcVector2D myVertex2;
   DtSdcVector2D myVertex3;
   DtSdcVector2D myOffset;
   DtSdcVector2D myScale;
   
   DtSdcColor myColor;
   unsigned myPattern;
   bool myFill;
   double myRotation;
   bool myFlashing;
   
   Dt2DGraphicalObjectStateRecord* myStateRecord;
};

class DL_DLL_IGCONVRLINK DtSdcTriangle3DObject : public DtSdcArea3DObject
{
public:
   DtSdcTriangle3DObject(DtExerciseConn* exConn, unsigned id, const DtVector& vertex1, 
      const DtVector& vertex2, const DtVector& vertex3, 
      DtVector offset = DtVector::zero(),
      DtSdcColor color = DtSdcColor::DtSdcWhite, 
      const DtString& textureDirectory = "", 
      const DtString& textureFilename = DtString::nullString(),
      int numTextureTiles = 0, bool flashing = false);
      
   
   // \brief Virtual destructor
   virtual ~DtSdcTriangle3DObject();
  
private:
   DtSdcTriangle3DObject();

   DtSdcTriangle3DObject(const DtSdcTriangle3DObject& orig);

   DtSdcTriangle3DObject& operator=(const DtSdcTriangle3DObject& rhs);

public:
   virtual const DtVector& vertex1() const;
   
   virtual void setVertex1(const DtVector& vertex1);
   
   virtual const DtVector& vertex2() const;
   
   virtual void setVertex2(const DtVector& vertex2);
   
   virtual const DtVector& vertex3() const;
   
   virtual void setVertex3(const DtVector& vertex3);
};

/*
      DtSdc2DTriangle
      DtSdc3DTriangle
*/
class DL_DLL_IGCONVRLINK DtSdcTrianglePduBase : public DtSdcPolyObjectPduBase
{
public:
   virtual void setPoint( int index, const DtVector &pos );
   virtual const DtVector point( int index ) const;

   virtual void setFromString(const char* str);
   virtual const char* string() const;

   virtual void printData() const;
};


class DL_DLL_IGCONVRLINK DtSdcTrianglePdu : public DtSdcTrianglePduBase
{
public:
    
   DtSdcTrianglePdu( DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
   DtSdcTrianglePdu(const DtNetViewControlPdu* initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
};

class DL_DLL_IGCONVRLINK DtSdcTrianglePduV0 : public DtSdcTrianglePduBase
{
public:
    
   DtSdcTrianglePduV0( DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
   DtSdcTrianglePduV0(const DtNetViewControlPdu* initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
};

class DL_DLL_IGCONVRLINK DtSdcAreaPduBase : public DtSdcPolyObjectPduBase
{
public:

   virtual void setNumPoints( int nPoints );
   virtual const int numPoints() const;

   virtual void setPoint( int index, const DtVector &pos );
   virtual const DtVector point( int index ) const;

   virtual void setTextureDirectory(const DtString& str);
   virtual const DtString textureDirectory() const;

   virtual void setTextureFilename(const DtString& str);
   virtual const DtString textureFilename() const;

   virtual void setNumTextureTiles( int numTextureTiles );
   virtual const int numTextureTiles() const;

   virtual void setFromString(const char* str);
   virtual const char* string() const;

   virtual void printData() const;

};


class DL_DLL_IGCONVRLINK DtSdcAreaPdu : public DtSdcAreaPduBase
{
public:

   DtSdcAreaPdu( DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
   DtSdcAreaPdu(const DtNetViewControlPdu* initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
};

class DL_DLL_IGCONVRLINK DtSdcAreaPduV0 : public DtSdcAreaPduBase
{
public:

   DtSdcAreaPduV0( DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
   DtSdcAreaPduV0(const DtNetViewControlPdu* initial, 
      DtBufferPtr buffer = DtUSE_INTERNAL_BUFFER );
};

#include <vrvVrl/legacyStealthControl.inl>