netStructs.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2023 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 <vlutil/vlUuid.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:
   DtNetU16 myCountry;
   DtNetU8 myService;
   DtNetU8 padding;
   DtNetU16 myPatchId;

   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 );
   }
};

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 */
};

class DT_DLL_VLPROTIND DtNetUuid
{
public:
   DtNetU8 data[16];

   DtNetUuid();
   DtNetUuid(const char* buff);
   DtNetUuid(const DtNetUuid& other);
   DtNetUuid(const DtVrlUuid& other);
   DtNetUuid& operator=(const DtNetUuid& other);
   DtNetUuid& operator=(const DtVrlUuid& other);
   bool operator==(const DtNetUuid& other) const;
   void swapBytes(const char* buff);
   void reverseSwapBytes(char* buff) const;
   operator DtVrlUuid() const;
};

class DT_DLL_VLPROTIND DtNetPointVariant
{
public:
   DtNetU32 pointType;
   DtNetU32 padding;
   union {
      DtNetVector64 location;
      DtNetUuid uuid;
   };

   DtNetPointVariant();
   DtNetPointVariant(const DtNetPointVariant& other);
   DtNetPointVariant& operator=(const DtNetPointVariant& other);
};

class DT_DLL_VLPROTIND DtNetWaypoints
{
public:
   DtNetInt32 count;
   DtNetInt32 padding;
   DtNetVector64 locations;   // [] a stand-in for a vector of waypoints

   DtNetWaypoints();
   DtNetWaypoints(const DtNetWaypoints& other);
   DtNetWaypoints& operator=(const DtNetWaypoints& other);
};

class DT_DLL_VLPROTIND DtNetPathVariant
{
public:
   DtNetU32 pathType;
   DtNetU32 padding;
   union {
      DtNetWaypoints waypoints;
      DtNetUuid uuid;
   };

   DtNetPathVariant();
   DtNetPathVariant(const DtNetPathVariant& other);
   DtNetPathVariant& operator=(const DtNetPathVariant& other);
};


//NETN METOC NET Structs
class DT_DLL_VLPROTIND DtNetWindStruct
{
public:
   DtNetFloat32 myDirection;
   DtNetFloat32 myHorizontalSpeed;
   DtNetFloat32 myVerticalSpeed;

   const DtNetWindStruct& operator=(const DtNetWindStruct& other);
   bool operator==(const DtNetWindStruct& rhs) const
   {
      return (myDirection == rhs.myDirection)
         && (myHorizontalSpeed == rhs.myHorizontalSpeed)
         && (myVerticalSpeed == rhs.myVerticalSpeed);
   }
   bool operator!=(const DtNetWindStruct& rhs) const
   {
      return !operator==(rhs);
   }
};

class DT_DLL_VLPROTIND DtNetPrecipitationStruct
{
public:
   DtNetInt32 myType;
   DtNetFloat32 myIntensity;

   const DtNetPrecipitationStruct& operator=(const DtNetPrecipitationStruct&);
   bool operator==(const DtNetPrecipitationStruct& rhs) const
   {
      return (myType == rhs.myType)
         && (myIntensity == rhs.myIntensity);
   }
   bool operator!=(const DtNetPrecipitationStruct& rhs) const
   {
      return !operator==(rhs);
   }
};

class DT_DLL_VLPROTIND DtNetHazeStruct
{
public:
   DtNetInt32 myType;
   DtNetFloat32 myDensity;

   const DtNetHazeStruct& operator=(const DtNetHazeStruct&);
   bool operator==(const DtNetHazeStruct& rhs) const
   {
      return (myType == rhs.myType)
         && (myDensity == rhs.myDensity);
   }
   bool operator!=(const DtNetHazeStruct& rhs) const
   {
      return !operator==(rhs);
   }
};

class DT_DLL_VLPROTIND DtNetLayerStruct
{
public:
   DtNetFloat32 myBase;
   DtNetFloat32 myThickness;

   const DtNetLayerStruct& operator=(const DtNetLayerStruct&);
   bool operator==(const DtNetLayerStruct& rhs) const
   {
      return (myBase == rhs.myBase)
         && (myThickness == rhs.myThickness);
   }
   bool operator!=(const DtNetLayerStruct& rhs) const
   {
      return !operator==(rhs);
   }
};

class DT_DLL_VLPROTIND DtNetCloudStruct
{
public:
   DtNetInt32 myType;
   DtNetFloat32 myCoverage;
   DtNetFloat32 myDensity;

   const DtNetCloudStruct& operator=(const DtNetCloudStruct&);
   bool operator==(const DtNetCloudStruct& rhs) const
   {
      return (myType == rhs.myType)
         && (myCoverage == rhs.myCoverage)
         && (myDensity == rhs.myDensity);
   }
   bool operator!=(const DtNetCloudStruct& rhs) const
   {
      return !operator==(rhs);
   }
};

class DT_DLL_VLPROTIND DtNetIceStruct
{
public:
   DtNetInt16 myType;
   DtNetFloat32 myThickness;
   DtNetFloat32 myCoverage;

   const DtNetIceStruct& operator=(const DtNetIceStruct&);
   bool operator==(const DtNetIceStruct& rhs) const
   {
      return (myType == rhs.myType)
         && (myThickness == rhs.myThickness)
         && (myCoverage == rhs.myCoverage);
   }
   bool operator!=(const DtNetIceStruct& rhs) const
   {
      return !operator==(rhs);
   }
};

class DT_DLL_VLPROTIND DtNetSnowStruct
{
public:
   DtNetFloat32 myDepth;
   DtNetFloat32 myDensity;

   const DtNetSnowStruct& operator=(const DtNetSnowStruct&);
   bool operator==(const DtNetSnowStruct& rhs) const
   {
      return (myDepth == rhs.myDepth)
         && (myDensity == rhs.myDensity);
   }
   bool operator!=(const DtNetSnowStruct& rhs) const
   {
      return !operator==(rhs);
   }
};

class DT_DLL_VLPROTIND DtNetWaterCurrentStruct
{
public:
   DtNetFloat32 myDirection;
   DtNetFloat32 mySpeed;

   const DtNetWaterCurrentStruct& operator=(const DtNetWaterCurrentStruct&);
   bool operator==(const DtNetWaterCurrentStruct& rhs) const
   {
      return (myDirection == rhs.myDirection)
         && (mySpeed == rhs.mySpeed);
   }
   bool operator!=(const DtNetWaterCurrentStruct& rhs) const
   {
      return !operator==(rhs);
   }
};


class DT_DLL_VLPROTIND DtNetWaveStruct
{
public:
   DtNetFloat32 myLength;
   DtNetFloat32 myHeight;
   DtNetInt32 myPeriod;
   DtNetFloat32 myDirection;

   const DtNetWaveStruct& operator=(const DtNetWaveStruct&);
   bool operator==(const DtNetWaveStruct& rhs) const
   {
      return (myLength == rhs.myLength)
         && (myHeight == rhs.myHeight)
         && (myPeriod == rhs.myPeriod)
         && (myDirection == rhs.myDirection);
   }
   bool operator!=(const DtNetWaveStruct& rhs) const
   {
      return !operator==(rhs);
   }
};


/***************************************************************
 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);