netStructs.h

Go to the documentation of this file.

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


#pragma once

#include <vlutil/vlTime.h>
#include <matrix/vlMath.h>
#include <matrix/vlTaitBryan.h>
#include <vlutil/vlNetTypes.h>
#include <vlutil/vlNetTimeStamp.h>
#include "oldTStamp.h"

class DT_DLL_VLPROTIND  DtEntityIdentifier;
class DT_DLL_VLPROTIND  DtBurstDescriptor;
class DT_DLL_VLPROTIND  DtEventId;
class DT_DLL_VLPROTIND  DtEntityType;
class DT_DLL_VLPROTIND  DtRadioEntityType;
class DT_DLL_VLPROTIND  DtSimulationAddress;

typedef DtSimulationAddress DtFederateId;

class DT_DLL_VLPROTIND DtNetFederateId
{
public:
   DtNetU16 site;
   DtNetU16 app;

   const DtFederateId& operator=(const DtFederateId &);
   const DtNetFederateId& operator=(const DtNetFederateId &);
};


class DT_DLL_VLPROTIND DtNetEntityMarking
{
  public:
    DtNetU8     DtCharacterSet;
#define DtMaxEntityMarkingLength                  11
    DtNetU8     DtText[DtMaxEntityMarkingLength];
};

class DT_DLL_VLPROTIND DtNetAggregateMarking
{
public:
   DtNetU8     DtCharacterSet;
#define DtMaxAggregateMarkingLength               31
   DtNetU8     DtText[DtMaxAggregateMarkingLength];
};

class DT_DLL_VLPROTIND DtNetEntityType
{
  public:
    DtNetU8    DtEntityKind;
    DtNetU8    DtDomain;
    DtNetU16   DtCountry;
    DtNetU8    DtCategory;
    DtNetU8    DtSubCategory;
    DtNetU8    DtSpecific;
    DtNetU8    DtExtra;
    
    const DtEntityType& operator=(const DtEntityType&);
    const DtNetEntityType& operator=(const DtNetEntityType &);
};

class DT_DLL_VLPROTIND DtNetRadioEntityType
{
  public:
    DtNetU8    kind;
    DtNetU8    domain;
    DtNetU16   country;
    DtNetU8    category;
    DtNetU8    nomenclatureVersion;
    DtNetU16   nomenclature;
    
    const DtRadioEntityType& operator=(const DtRadioEntityType &);
    const DtNetRadioEntityType& operator=(const DtNetRadioEntityType &);
};

class DT_DLL_VLPROTIND DtNetBurstDescriptor
{
  public:
    DtNetEntityType DtMunition;
    DtNetU16 DtWarhead;
    DtNetU16 DtFuze;
    DtNetU16 DtQuantity;
    DtNetU16 DtRate;

    const DtBurstDescriptor& operator=(const DtBurstDescriptor&);
    const DtNetBurstDescriptor& operator=(const DtNetBurstDescriptor&);
};

class DT_DLL_VLPROTIND DtNetSimulationAddress
{
 public:
    DtNetU16   DtSite;
    DtNetU16   DtHost;

    const DtSimulationAddress& operator=(const DtSimulationAddress&);
    const DtNetSimulationAddress& operator=(const DtNetSimulationAddress&);
    bool operator==(const DtNetSimulationAddress& rhs) const
    {
       return (DtSite == rhs.DtSite)
          && (DtHost == rhs.DtHost);
    }
    bool operator!=(const DtNetSimulationAddress& rhs) const
    {
       return !operator==(rhs);
    }
};

class DT_DLL_VLPROTIND DtNetEntityIdentifier
{
  public:
    DtNetSimulationAddress DtSimulator;
    DtNetU16         DtEntity;

    const DtEntityIdentifier& operator=(const DtEntityIdentifier&);
    const DtNetEntityIdentifier& operator=(const DtNetEntityIdentifier&);
    bool operator==(const DtNetEntityIdentifier& rhs) const
    {
       return (DtSimulator == rhs.DtSimulator)
          && (DtEntity == rhs.DtEntity);
    }
    bool operator!=(const DtNetEntityIdentifier& rhs) const
    {
       return !operator==(rhs);
    }
};

class DT_DLL_VLPROTIND DtNetObjectType
{
public:
   DtNetU8                      myDomain;
   DtNetU8                      myKind;
   DtNetU8                      myCategory;
   DtNetU8                      mySubcategory;
   
   const DtNetObjectType& operator=(const DtNetObjectType&);
   bool operator==(const DtNetObjectType& rhs) const
   {
      return (myDomain == rhs.myDomain)
         && (myKind == rhs.myKind)
         && (myCategory == rhs.myCategory)
         && (mySubcategory == rhs.mySubcategory);
   }
   bool operator!=(const DtNetObjectType& rhs) const
   {
      return !operator==(rhs);
   }
};

class DT_DLL_VLPROTIND DtNetPatchIdentifier
{
public:

   bool operator == ( const DtNetPatchIdentifier& rhs ) const
   {
      return myCountry == rhs.myCountry
         && myService == rhs.myService
         && myPatchId == rhs.myPatchId;
   }

   bool operator != ( const DtNetPatchIdentifier& rhs ) const
   {
      return ! ( *this == rhs );
   }

   DtNetU16 myCountry;
   DtNetU8 myService;
   DtNetU8 padding;
   DtNetU16 myPatchId;

};

class DT_DLL_VLPROTIND DtNet64Vector
{
  public:
    DtNet64Vector()
    {rep[0] = rep[1] = rep[2] = 0.0;}
    DtNet64Vector(const DtVector &vec)
    {rep[0] = vec[0]; rep[1] = vec[1]; rep[2] = vec[2];}
    DtVector operator=(const DtVector &vec) 
    {rep[0] = vec[0]; rep[1] = vec[1]; rep[2] = vec[2]; return vec;}
    operator DtVector() const {return DtVector(rep[0], rep[1], rep[2]);}
    DtNetFloat64 &operator[](int i) { return rep[i];}
    DtNetFloat64 operator[](int i) const { return rep[i];}
  private:
    DtNetFloat64 rep[3];
};

class DT_DLL_VLPROTIND DtNet32Vector
{
  public:
    DtNet32Vector()
    {rep[0] = rep[1] = rep[2] = (float)0.0;}
    DtNet32Vector(const DtVector &vec)
    {rep[0] = (float)vec[0]; rep[1] = (float)vec[1]; rep[2] = (float)vec[2];}
    DtVector operator=(const DtVector &vec)  
    {rep[0] = (float)vec[0]; rep[1] = (float)vec[1]; rep[2] = (float)vec[2]; return vec;}
    operator DtVector() const 
    {return DtVector((DtFloat32) rep[0], (DtFloat32) rep[1], (DtFloat32) rep[2]);}
    DtNetFloat32 &operator[](int i) { return rep[i];}
    DtNetFloat32 operator[](int i) const { return rep[i];}
  private:
    DtNetFloat32 rep[3];
};

class DT_DLL_VLPROTIND DtNetEulerAngles
{
  public:
   DtNetEulerAngles() { psi = theta = phi = (float)0.0;}
   DtNetEulerAngles(const DtTaitBryan &tait)
   {psi = (DtFloat32)tait.psi(); theta = (DtFloat32)tait.theta(); phi = (DtFloat32)tait.phi();} 
   DtTaitBryan operator=(const DtTaitBryan &tait)
   {psi = (DtFloat32)tait.psi(); theta = (DtFloat32)tait.theta(); phi = (DtFloat32)tait.phi(); return tait;}   
   operator DtTaitBryan() const {return DtTaitBryan(psi, theta, phi);}
   DtNetFloat32 psi; /* Counter clockwise about z */
   DtNetFloat32 theta; /* Counter clockwise about y */
   DtNetFloat32 phi; /* Counter clockwise about x */
};

/***************************************************************
 These structures don't need to be C++ classes even on little endian machines. 
****************************************************************/

typedef struct DtNetArtParamRecordRPR1
{
    DtNetU8       myChange;
    DtNetU8       padding;
    DtNetU16      myAttachedTo;
    DtNetU32      myArtOrAttached;
    DtNetU32      myClass;
    DtNetU32      myTypeMetric;
    DtNetFloat32  myValue;
} DtNetArtParamRecordRPR1;

typedef struct DtNetArtParamRecord
{
    DtNetU8       artOrAttached;
    DtNetU8       DtChange;
    DtNetU16      DtAttachedTo;
    DtNetU32      DtType;
    DtNet64Bits   DtValue;
} DtNetArtParamRecord;

typedef DtNetArtParamRecord DtArticulatedParts;
typedef DtNetArtParamRecord DtNetArtPartRecord;

typedef struct DtNetEntityAssociationRecord
{
   DtNetU8       myArtOrAttached;
   DtNetU8       myChange;
   DtNetU8       myAssociationStatus;
   DtNetU8       myAssociationType;
   DtNetEntityIdentifier   myEntityId;
   DtNetU16      myOwnStationLocation;
   DtNetU8       myPhysicalConnectionType;
   DtNetU8       myGroupMemberType;
   DtNetU16      myGroupNumber;
} DtNetEntityAssociationRecord;

typedef struct DtNetEntityTypeRecord
{
   DtNetU8       myArtOrAttached;
   DtNetU8       myChange;
   DtNetEntityType   myEntityType;
   DtNetU16      padding16;
   DtNetU32      padding32;
} DtNetEntityTypeRecord;

typedef struct DtNetSeparationRecord
{
   DtNetU8       myArtOrAttached;
   DtNetU8       mySeparationReason;
   DtNetU8       myPreEntityIndicator;
   DtNetU8       padding8;
   DtNetEntityIdentifier   myParentEntityId;
   DtNetU16      padding16;
   DtNetU16      myStationName;
   DtNetU16      myStationNumber;
} DtNetSeparationRecord;

typedef struct DtNetAttachedPartRPR1
{
   DtNetU8           myChange;
   DtNetU8           padding;
   DtNetU16          myAttachedTo;
   DtNetU32          myArtOrAttatched;
   DtNetU32          myStation;
   DtNetEntityType   myType;
} DtNetAttachedPartRPR1;

typedef struct DtNetAttachedPart
{

   DtNetU8           myArtOrAttached;
   DtNetU8           myChange;
   DtNetU16          myAttachedTo;
   DtNetU32          myStation;
   DtNetEntityType   myType;
} DtNetAttachedPart;

typedef struct DtNetVPRecord
{
   DtNetU8           myVPType;
   DtNetU8           myUnused1;
   DtNetU16          myUnused2;
   DtNetU32          myUnused3;
   DtNetU32          myUnused4;
   DtNetU32          myUnused5;
} DtNetVPRecord;

typedef struct DtNetAngularVelocity
{
    DtNetFloat32 wx;
    DtNetFloat32 wy; 
    DtNetFloat32 wz; 
} DtNetAngularVelocity;

typedef struct DtNetLinearVelocity
{
   bool operator==(const DtNetLinearVelocity& rhs) const
   {
      return (DtX == rhs.DtX)
         && (DtY == rhs.DtY)
         && (DtZ == rhs.DtZ);
   }
   bool operator!=(const DtNetLinearVelocity& rhs) const
   {
      return !operator==(rhs);
   }
    DtNetFloat32 DtX;
    DtNetFloat32 DtY;
    DtNetFloat32 DtZ;
} DtNetLinearVelocity;

typedef struct DtNetLinearAcceleration
{
   bool operator==(const DtNetLinearAcceleration& rhs) const
   {
      return (DtX == rhs.DtX)
         && (DtY == rhs.DtY)
         && (DtZ == rhs.DtZ);
   }
   bool operator!=(const DtNetLinearAcceleration& rhs) const
   {
      return !operator==(rhs);
   }
   DtNetFloat32 DtX;
   DtNetFloat32 DtY;
   DtNetFloat32 DtZ;
} DtNetLinearAcceleration;

typedef struct DtNetWorldCoordinates
{
   bool operator==(const DtNetWorldCoordinates& rhs) const
   {
      return (DtX == rhs.DtX)
         && (DtY == rhs.DtY)
         && (DtZ == rhs.DtZ);
   }
   bool operator!=(const DtNetWorldCoordinates& rhs) const
   {
      return !operator==(rhs);
   }
    DtNetFloat64 DtX;
    DtNetFloat64 DtY;
    DtNetFloat64 DtZ;
} DtNetWorldCoordinates;

typedef struct DtNetEntityCoordinates
{
   bool operator==(const DtNetEntityCoordinates& rhs) const
   {
      return (DtX == rhs.DtX)
         && (DtY == rhs.DtY)
         && (DtZ == rhs.DtZ);
   }
   bool operator!=(const DtNetEntityCoordinates& rhs) const
   {
      return !operator==(rhs);
   }
    DtNetFloat32 DtX;
    DtNetFloat32 DtY;
    DtNetFloat32 DtZ;
} DtNetEntityCoordinates;

typedef struct DtNetTopoUpCoord
{
    DtNetFloat32 East;
    DtNetFloat32 North;
    DtNetFloat32 Up;
} DtNetTopoUpCoord;

typedef struct 
{
    DtNetInt32          hour;
    DtNetTimeStamp      hourFrac;
} DtNetClockTime;

DT_DLL_VLPROTIND DtTime DtClockTime2AbsTime(const DtNetClockTime *clock);
DT_DLL_VLPROTIND void DtAbsTime2ClockTime(DtTime absTime, DtNetClockTime *clock);