BVB Source Codes

CRYENGINE Show XMLCPB_Common.cpp Source code

Return Download CRYENGINE: download XMLCPB_Common.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4. *************************************************************************/
  5.  
  6. #include "StdAfx.h"
  7. #include "XMLCPB_Common.h"
  8. #include <CryCore/TypeInfo_impl.h>
  9.  
  10. using namespace XMLCPB;
  11.  
  12. // !!!this array needs to be in the same order and with same elements than eAttrDataType!!!
  13. STypeInfo s_TypeInfos[DT_NUMTYPES] =
  14. {
  15.         //...basic types.......
  16.         { DT_STR,       2,                                 DT_STR,     "DT_STR"       },
  17.         { DT_INT32,     sizeof(uint32),                    DT_INT32,   "DT_INT32"     },
  18.         { DT_F1,        sizeof(float),                     DT_F1,      "DT_F1"        },
  19.         { DT_F3,        sizeof(float) * 3,                 DT_F3,      "DT_F3"        },
  20.         { DT_F4,        sizeof(float) * 4,                 DT_F4,      "DT_F4"        },
  21.         { DT_INT64,     sizeof(uint64),                    DT_INT64,   "DT_INT64"     },
  22.         { DT_RAWDATA,   VARIABLE_DATA_SIZE,                DT_RAWDATA, "DT_RAWDATA"   },
  23.  
  24.         // compressed types....
  25.         { DT_POS16,     sizeof(uint16),                    DT_INT32,   "DT_POS16"     },
  26.         { DT_NEG16,     sizeof(uint16),                    DT_INT32,   "DT_NEG16"     },
  27.         { DT_POS8,      sizeof(uint8),                     DT_INT32,   "DT_POS8"      },
  28.         { DT_NEG8,      sizeof(uint8),                     DT_INT32,   "DT_NEG8"      },
  29.         { DT_F1_1DEC,   sizeof(int8),                      DT_F1,      "DT_F1_1DEC"   },
  30.         { DT_F3_1CONST, sizeof(float) * 2 + sizeof(uint8), DT_F3,      "DT_F3_1CONST" },
  31.         { DT_F3_2CONST, sizeof(float) + sizeof(uint8),     DT_F3,      "DT_F3_2CONST" },
  32.         { DT_F3_3CONST, sizeof(uint8),                     DT_F3,      "DT_F3_3CONST" },
  33.         { DT_F4_1CONST, sizeof(float) * 3 + sizeof(uint8), DT_F4,      "DT_F4_1CONST" },
  34.         { DT_F4_2CONST, sizeof(float) * 2 + sizeof(uint8), DT_F4,      "DT_F4_2CONST" },
  35.         { DT_F4_3CONST, sizeof(float) + sizeof(uint8),     DT_F4,      "DT_F4_3CONST" },
  36.         { DT_F4_4CONST, sizeof(uint8),                     DT_F4,      "DT_F4_4CONST" },
  37.  
  38.         //........numeric constants......
  39.         { DT_0,         0,                                 DT_INT32,   "DT_0"         },
  40.         { DT_1,         0,                                 DT_INT32,   "DT_1"         },
  41.         { DT_2,         0,                                 DT_INT32,   "DT_2"         },
  42.         { DT_3,         0,                                 DT_INT32,   "DT_3"         },
  43.         { DT_4,         0,                                 DT_INT32,   "DT_4"         },
  44.         { DT_5,         0,                                 DT_INT32,   "DT_5"         },
  45.         { DT_6,         0,                                 DT_INT32,   "DT_6"         },
  46.         { DT_7,         0,                                 DT_INT32,   "DT_7"         },
  47.         { DT_8,         0,                                 DT_INT32,   "DT_8"         },
  48.         { DT_9,         0,                                 DT_INT32,   "DT_9"         },
  49.         { DT_10,        0,                                 DT_INT32,   "DT_10"        },
  50.         { DT_255,       0,                                 DT_INT32,   "DT_255"       },
  51.  
  52.         { DT_F3_100,    0,                                 DT_F3,      "DT_F3_100"    },
  53.         { DT_F3_010,    0,                                 DT_F3,      "DT_F3_010"    },
  54.         { DT_F3_001,    0,                                 DT_F3,      "DT_F3_001"    },
  55. };
  56.  
  57. // string constants
  58. const char* s_constStrings[] =
  59. {
  60.         "n",
  61.         "table",
  62.         "RigidBodyEx",
  63.         "bRigidBodyActive",
  64.         "false",
  65.         "true",
  66.         "Idle",
  67.         "bActive",
  68.         "Light",
  69.         "h",
  70.         "s",
  71.         "vec",
  72.         "ParticleEffect",
  73.         "SmartObject",
  74.         "b",
  75.         "TagPoint",
  76.         "GrabableLedge",
  77.         "health",
  78.         "nParticleSlot",
  79.         "zero",
  80.         "enabled",
  81.         "state",
  82.         "Alive",
  83.         "currentSlot",
  84.         "LastHit",
  85.         "pos",
  86.         "impulse",
  87.         "shooterId",
  88.         "bIgnoreObstruction",
  89.         "bIgnoreCulling",
  90. };
  91.  
  92. //////////////////////////////////////////////////////////////////////////
  93. // some of the types are a bit procedural and need this
  94.  
  95. void XMLCPB::InitializeDataTypeInfo()
  96. {
  97.         static_assert(CRY_ARRAY_COUNT(s_constStrings) == DT_NUM_CONST_STR, "Unexpected array size!");
  98.  
  99.         // str constant types initialization
  100.         for (int i = DT_FIRST_CONST_STR; i <= DT_LAST_CONST_STR; i++)
  101.         {
  102.                 s_TypeInfos[i].type = eAttrDataType(i);
  103.                 s_TypeInfos[i].pName = "strConstant";
  104.                 s_TypeInfos[i].size = 0;
  105.                 s_TypeInfos[i].basicType = DT_STR;
  106.         }
  107.  
  108.         // some checking
  109.         for (uint i = 0; i < DT_NUMTYPES; ++i)
  110.         {
  111.                 const STypeInfo& info = s_TypeInfos[i];
  112.                 assert(info.type == i);
  113.                 assert(info.basicType < DT_NUM_BASIC_TYPES);
  114.         }
  115. }
  116.  
  117. //////////////////////////////////////////////////////////////////////////
  118.  
  119. const char* XMLCPB::GetConstantString(uint32 ind)
  120. {
  121.         assert(ind < DT_NUM_CONST_STR);
  122.         return s_constStrings[ind];
  123. }
  124.  
  125. //////////////////////////////////////////////////////////////////////////
  126.  
  127. eAttrDataType XMLCPB::GetBasicDataType(eAttrDataType type)
  128. {
  129.         return s_TypeInfos[type].basicType;
  130. }
  131.  
  132. //////////////////////////////////////////////////////////////////////////
  133.  
  134. uint32 XMLCPB::GetDataTypeSize(eAttrDataType type)
  135. {
  136.         return s_TypeInfos[type].size;
  137. }
  138.  
  139. //////////////////////////////////////////////////////////////////////////
  140.  
  141. const char* XMLCPB::GetDataTypeName(eAttrDataType type)
  142. {
  143.         return s_TypeInfos[type].pName;
  144. }
  145.  
downloadXMLCPB_Common.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top