vrfEnumerationExtensions.h

Go to the documentation of this file.

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

#pragma once

// DtEntityTypeEnumerations:
//
// This header file contains the extensions to the RPR/DIS enumeration,
// and are used to specify entity types.  It contains enumerations to be
// used to specify individual, aggregate, and non-entity object types.

#include <vrfExtProtocol/vrfExtProtocolDefines.h>
#include <vlpi/entityType.h>
#include <vlpi/entityTypes.h>

DT_DLL_vrfExtProtocol bool EntityTypeHasWildCard(const DtEntityType&);
DT_DLL_vrfExtProtocol void SetEntityTypeValue(DtEntityType&, int index, int value);
DT_DLL_vrfExtProtocol int EntityTypeValue(const DtEntityType&, int);

inline bool EntityTypeHasWildCard(const DtEntityType& ot)
{
   for (int i = 0; i < 7; i++)
   {
      if (EntityTypeValue(ot, i) == -1)
      {
         return true;
      }
   }
   
   return false;
}

inline int EntityTypeValue(const DtEntityType& ot, int i)
 {
    switch (i)
    {
       case 0:
         return ot.kind();
       case 1:
         return ot.domain();
       case 2:
         return ot.country();
       case 3:
         return ot.category();
       case 4:
         return ot.subCategory();
       case 5:
         return ot.specific();
       case 6:
      return ot.extra();
   }
 
   return ot.kind();
 }

inline void SetEntityTypeValue(DtEntityType& ot, int i, int v)
 {
    switch (i)
    {
       case 0:
         return ot.setKind(v);
       case 1:
         return ot.setDomain(v);
       case 2:
         return ot.setCountry(v);
       case 3:
         return ot.setCategory(v);
       case 4:
         return ot.setSubCategory(v);
       case 5:
         return ot.setSpecific(v);
       case 6:
         return ot.setExtra(v);
    }
 }
 
// This is a deviation from the document "Enumerations and Bit-Encoded Values
// for Use with Protocols for Distributed Interactive Simulation", IST-CF-99-01.
// The enumeration for DtAggregateKind should start with 0, but I am starting with
// 10, to ensure that entity types will be unique.  
// enum DtAggregateKind
// {
//   DtAggregateKindOther =                 0,
//   DtAggregateKindMilitaryHierarchy =     1,
//   DtAggregateKindCommonType =            2,
//   DtAggregateKindCommonMission =         3,
//   DtAggregateKindSimilarCapabilities =   4,
//   DtAggregateKindCommonLocation =        5
//};
const DtEntityKind DtAggregateKindOther = DtEntityKind(10);
const DtEntityKind DtAggregateKindMilitaryHierarchy = DtEntityKind(11);
const DtEntityKind DtAggregateKindCommonType = DtEntityKind(12);
const DtEntityKind DtAggregateKindCommonMission = DtEntityKind(13);
const DtEntityKind DtAggregateKindSimilarCapabilities = DtEntityKind(14);
const DtEntityKind DtAggregateKindCommonLocation = DtEntityKind(15);
const DtEntityKind DtSimArtPartKind = DtEntityKind(20);

// Extension of entity kind to represent non-entity objects, such as
// control objects (control points, routes, phase lines, obstacles, etc.)
const DtEntityKind DtPointObjectKind = DtEntityKind(16);
const DtEntityKind DtLinearObjectKind = DtEntityKind(17);
const DtEntityKind DtArealObjectKind = DtEntityKind(18);
const DtEntityKind DtCircleObjectKind = DtEntityKind(19);
const DtEntityKind DtTextObjectKind = DtEntityKind(20);
const DtEntityKind DtWeatherObjectKind = DtEntityKind(21);
const DtEntityKind DtCloudLayerObjectKind = DtEntityKind(25);

// Extension of entity kind to represent remote graphic objects.
const DtEntityKind Dt2DGraphicalObjectKind = DtEntityKind(22);
const DtEntityKind Dt3DGraphicalObjectKind = DtEntityKind(23);
const DtEntityKind DtBulkGraphicalObjectKind = DtEntityKind(24);

// The Domain and Country field enumerations are the same as used for Entity Type.

// The Category field enumerations for Kind-field = Military Hierarchy specify 
// the Echelon Level of the aggregate, and are enumerated as follows:
// Kind  Domain   Country  Cat   Scat  Specific
// 1     1        225
// KRO - I have extended the enumeration to include DtAggregateCategoryForce,
// which represents the force level (i.e. friendly, opposing, neutral).
// All of the entries after (and including DtAggregateCategoryForce) are 
// extensions to the standard.

enum DtAggregateCategory
{
   DtAggregateCategoryOther =                0,
   DtAggregateCategoryIndividualVehicle =    1,
   DtAggregateCategoryElement =              2,
   DtAggregateCategoryPlatoon =              3,
   DtAggregateCategoryBattery =              4,
   DtAggregateCategoryCompany =              5,
   DtAggregateCategoryBattalion =            6,
   DtAggregateCategoryRegiment =             7,
   DtAggregateCategoryBrigade =              8,
   DtAggregateCategoryDivision =             9,
   DtAggregateCategoryCorps =               10,
   DtAggregateCategoryForce =               11,
   DtAggregateCategoryTeam =                12,
   DtAggregateCategorySquad =               13,
   DtAggregateCategorySection =             14
};

// The Subcategory field enumerations for Kind field = Military Hierarchy 
// specify the Echelon Type of the aggregate, and are enumerated as follows.  
// Not all of the following echelon types are applicable to each of the above 
// enumerated Categories.

// Kind  Domain   Country  Cat   Scat  Specific
// 1     1        225
// KRO - I have extended the enumeration to include entries for 
// DtAggregateCategoryForce, consisting of DtAggregateSubcategoryForceFriendly,
// DtAggregateSubcategoryForceOpposing, DtAggregateSubcategoryForceNeutral,
// and DtAggregateSubcategoryForceOther.
enum DtAggregateSubcategory
{
   DtAggregateSubcategoryOther =                      0,
   DtAggregateSubcategoryCavalryTroop =               1,
   DtAggregateSubcategoryArmor =                      2,
   DtAggregateSubcategoryInfantry =                   3,
   DtAggregateSubcategoryMechanizedInfantry =         4,
   DtAggregateSubcategoryCavalry =                    5,
   DtAggregateSubcategoryArmoredCavalry =             6,
   DtAggregateSubcategoryArtillery =                  7,
   DtAggregateSubcategorySelfPropelledArtillery =     8,
   DtAggregateSubcategoryCloseAirSupport =            9,
   DtAggregateSubcategoryEngineer =                  10,
   DtAggregateSubcategoryAirDefenseArtillery =       11,
   DtAggregateSubcategoryAntiTank =                  12,
   DtAggregateSubcategoryArmyAviationFixedWing =     13,
   DtAggregateSubcategoryArmyAviationRotaryWing =    14,
   DtAggregateSubcategoryArmyAttackHelicopter =      15,
   DtAggregateSubcategoryAirCavalry =                16,
   DtAggregateSubcategoryArmorHeavyTaskForce =       17,
   DtAggregateSubcategoryMotorizedRifle =            18,
   DtAggregateSubcategoryMechanizedHeavyTaskForce =  19,
   DtAggregateSubcategoryCommandPost =               20,
   DtAggregateSubcategoryCEWI =                      21,
   DtAggregateSubcategoryTankOnly =                  22,
   DtAggregateSubcategoryForceFriendly =             23,
   DtAggregateSubcategoryForceOpposing =             24,
   DtAggregateSubcategoryForceNeutral =              25,
   DtAggregateSubcategoryForceOther =                26,
   DtAggregateSubcategoryCOLT =                      27,
   DtAggregateSubcategorySurface =                   28,
   DtAggregateSubcategorySubsurface =                29,
   DtAggregateSubcategoryRecon=                      30,     //MAS-BSVT
   DtAggregateSubcategoryCombatServiceSupport=       31     //MEM-BSVT
};
   
// The Specific field enumerations for Kind field = Military Hierarchy specify 
// whether the aggregate unit contains a headquarters, and is enumerated as 
// follows.

// Kind  Domain   Country  Cat   Scat  Specific
// 1     1        225

enum DtAggregateSpecific
{
   DtAggregateSpecificNoheadquarters =       0,
   DtAggregateSpecificContainsHeadquarters = 1
};

// Extended specific type for Dismounted Infantry aggregates. 
enum DtDismountedInfantryAggregateSpecific
{
   DtDIAggSection = 201
};

// Subcategories for use with the Kind field = DtPointObjectKind
enum DtPointObjectCategory
{
   DtPointObjectCategoryOther =              0,
   DtPointObjectCategoryControlPoint =       1,
   DtPointObjectCategoryTargetPoint =        2,
   DtPointObjectCategoryMarker =             3
};

// Subcategories for use with the Kind field = DtLinearObjectKind
enum DtLinearObjectCategory
{
   DtLinearObjectCategoryOther =             0,
   DtLinearObjectCategoryPhaseLine =         1,
   DtLinearObjectCategoryRoute =             2
};

// Subcategories for use with the Kind field = DtArealObjectKind
enum DtArealObjectCategory
{
   DtArealObjectCategoryOther =              0,
   DtArealObjectCategoryControlArea =        1,
   DtArealObjectCategoryObstacle =           2,
   DtArealObjectCategoryDisaggregationArea = 3
};

//Kinds for Supertype interaction
enum DtInteractionKind
{
   DtInteractionKindOther =                  0,
   DtInteractionKindFire =                   1,
   DtInteractionKindDetonate =               2
};

enum DtLinearObjectRouteSubcategory
{
   DtLinearObjectRouteSubcategoryOther = 0,
   DtLinearObjectRouteSubcategoryAggregateFormation = 29,
   DtLinearObjectRouteSubcategoryPathPlanning = 30,
   DtLinearObjectRouteSubcategoryEmbarkationPlanning = 31,
   DtLinearObjectRouteSubcategoryLandingPlanning = 32
};

enum DtWeatherObjectCategory
{
   DtWeatherObjectCategoryOther =      0,
   DtWeatherObjectCategoryGlobal =     1
};

// More categories are added for the Remote Graphics API
enum Dt2DGraphicalObjectCategory
{
   Dt2DGraphicalObjectCategoryOther = 0,
   Dt2DGraphicalObjectCategoryEllipse = 1,
   Dt2DGraphicalObjectCategoryLine = 2,
   Dt2DGraphicalObjectCategoryRectangle = 3,
   Dt2DGraphicalObjectCategoryText = 4,
   Dt2DGraphicalObjectCategoryTriangle = 5
};


enum Dt3DGraphicalObjectCategory
{
   Dt3DGraphicalObjectCategoryOther = 0,
   Dt3DGraphicalObjectCategoryArea = 1,
   Dt3DGraphicalObjectCategoryCuboid = 2,
   Dt3DGraphicalObjectCategoryCylinder = 3,
   Dt3DGraphicalObjectCategoryEllipsoid = 4,
   Dt3DGraphicalObjectCategoryLine = 5,
   Dt3DGraphicalObjectCategoryText = 6,
   Dt3DGraphicalObjectCategoryAttributeGroup = 7, 
   Dt3DGraphicalObjectCategoryAttributeGroupTemplate = 8,
   Dt3DGraphicalObjectCategoryAttributeTemplate = 9 
};

enum Dt3DAttributeSubcategory
{
   Dt3DAttributeSubcategoryOther = 0,
   Dt3DAttributeSubcategorySingleValue = 1,
   Dt3DAttributeSubcategoryBarGraph = 2,
   Dt3DAttributeSubcategoryXYPlot = 3,
   Dt3DAttributeSubcategoryBitmap = 4
};

static const char DtEnvironmentalFormattingData[] = "Environmental_Formatting_Data";