BVB Source Codes

CRYENGINE Show XMLCPB_AttrReader.cpp Source code

Return Download CRYENGINE: download XMLCPB_AttrReader.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_AttrReader.h"
  8. #include "XMLCPB_Reader.h"
  9.  
  10. using namespace XMLCPB;
  11.  
  12. //////////////////////////////////////////////////////////////////////////
  13. // format in mem: look at CAttrLive::Compact()
  14.  
  15. CAttrReader::CAttrReader(CReader& Reader)
  16.         : m_Reader(Reader)
  17.         , m_addr(XMLCPB_INVALID_FLATADDR)
  18.         , m_nameId(XMLCPB_INVALID_ID)
  19.         , m_type(DT_INVALID)
  20. {
  21. }
  22.  
  23. //////////////////////////////////////////////////////////////////////////
  24.  
  25. void CAttrReader::InitFromCompact(FlatAddr addr, uint16 header)
  26. {
  27.         assert(addr != XMLCPB_INVALID_FLATADDR);
  28.  
  29.         m_type = eAttrDataType(header & MASK_TYPEID);
  30.         m_nameId = header >> BITS_TYPEID;  // nameStringId is always in the upper part, typeID in the lower part
  31.         m_addr = addr;
  32. }
  33.  
  34. //////////////////////////////////////////////////////////////////////////
  35.  
  36. FlatAddr CAttrReader::GetAddrNextAttr() const
  37. {
  38.         if (m_type != DT_RAWDATA)
  39.                 return GetDataAddr() + GetDataTypeSize(m_type);
  40.  
  41.         // Read in the size of the raw data which should be stored first at our location
  42.         uint32 size;
  43.         FlatAddr addr = m_Reader.ReadFromBuffer(GetDataAddr(), size);
  44.         return addr + size;
  45. }
  46.  
  47. //////////////////////////////////////////////////////////////////////////
  48.  
  49. const char* CAttrReader::GetName() const
  50. {
  51.         return m_Reader.GetAttrNamesTable().GetString(m_nameId);
  52. }
  53.  
  54. //////////////////////////////////////////////////////////////////////////
  55.  
  56. void CAttrReader::Get(int32& val) const
  57. {
  58.         if (m_type >= DT_0 && m_type <= DT_10)
  59.         {
  60.                 val = m_type - DT_0;
  61.                 return;
  62.         }
  63.  
  64.         switch (m_type)
  65.         {
  66.         case DT_POS8:
  67.                 {
  68.                         uint8 rawVal;
  69.                         m_Reader.ReadFromBuffer(GetDataAddr(), rawVal);
  70.                         val = rawVal;
  71.                         break;
  72.                 }
  73.  
  74.         case DT_POS16:
  75.                 {
  76.                         uint16 rawVal;
  77.                         m_Reader.ReadFromBufferEndianAware(GetDataAddr(), rawVal);
  78.                         val = rawVal;
  79.                         break;
  80.                 }
  81.  
  82.         case DT_255:
  83.                 {
  84.                         val = 255;
  85.                         break;
  86.                 }
  87.  
  88.         case DT_INT32:
  89.                 {
  90.                         m_Reader.ReadFromBufferEndianAware(GetDataAddr(), val);
  91.                         break;
  92.                 }
  93.  
  94.         case DT_NEG16:
  95.                 {
  96.                         uint16 rawVal;
  97.                         m_Reader.ReadFromBufferEndianAware(GetDataAddr(), rawVal);
  98.                         val = -int(rawVal);
  99.                         break;
  100.                 }
  101.  
  102.         case DT_NEG8:
  103.                 {
  104.                         uint8 rawVal;
  105.                         m_Reader.ReadFromBuffer(GetDataAddr(), rawVal);
  106.                         val = -int(rawVal);
  107.                         break;
  108.                 }
  109.  
  110.         case DT_STR:
  111.                 {
  112.                         const char* pStr = NULL;
  113.                         Get(pStr);
  114.                         if (pStr)
  115.                                 val = atoi(pStr);
  116.                         break;
  117.                 }
  118.  
  119.         case DT_0:
  120.                 {
  121.                         val = 0;
  122.                         break;
  123.                 }
  124.  
  125.         default:
  126.                 {
  127.                         assert(false);
  128.                         break;
  129.                 }
  130.         }
  131. }
  132.  
  133. //////////////////////////////////////////////////////////////////////////
  134.  
  135. void CAttrReader::Get(int64& val) const
  136. {
  137.         switch (m_type)
  138.         {
  139.         case DT_INT64:
  140.                 m_Reader.ReadFromBufferEndianAware(GetDataAddr(), val);
  141.                 break;
  142.  
  143.         default:
  144.                 {
  145.                         int32 int32Val;
  146.                         Get(int32Val);
  147.                         val = int32Val;
  148.                         break;
  149.                 }
  150.         }
  151. }
  152.  
  153. void CAttrReader::Get(uint64& val) const
  154. {
  155.         int64 valInt64;
  156.         Get(valInt64);
  157.         val = uint64(valInt64);
  158. }
  159.  
  160. //////////////////////////////////////////////////////////////////////////
  161.  
  162. void CAttrReader::Get(uint& val) const
  163. {
  164.         int valInt;
  165.         Get(valInt);
  166.         val = uint(valInt);
  167. }
  168.  
  169. void CAttrReader::Get(int16& val) const
  170. {
  171.         int valInt;
  172.         Get(valInt);
  173.         val = valInt;
  174. }
  175.  
  176. void CAttrReader::Get(int8& val) const
  177. {
  178.         int valInt;
  179.         Get(valInt);
  180.         val = valInt;
  181. }
  182.  
  183. void CAttrReader::Get(uint8& val) const
  184. {
  185.         int valInt;
  186.         Get(valInt);
  187.         val = valInt;
  188. }
  189.  
  190. void CAttrReader::Get(uint16& val) const
  191. {
  192.         int valInt;
  193.         Get(valInt);
  194.         val = valInt;
  195. }
  196.  
  197. void CAttrReader::Get(bool& val) const
  198. {
  199.         int valInt;
  200.         Get(valInt);
  201.         val = valInt != 0;
  202. }
  203.  
  204. //////////////////////////////////////////////////////////////////////////
  205.  
  206. void CAttrReader::Get(const char*& pStr) const
  207. {
  208.         if (m_type == DT_RAWDATA) // very big strings are stored as raw data
  209.         {
  210.                 uint32 size;
  211.                 FlatAddr addr = m_Reader.ReadFromBuffer(GetDataAddr(), size);
  212.                 pStr = (const char*)(m_Reader.GetPointerFromFlatAddr(addr));
  213.                 assert(pStr[size - 1] == 0);
  214.                 return;
  215.         }
  216.         if (IsTypeStrConstant(m_type))
  217.         {
  218.                 assert(m_type >= DT_FIRST_CONST_STR && m_type <= DT_LAST_CONST_STR);
  219.                 pStr = GetConstantString(m_type - DT_FIRST_CONST_STR);
  220.                 return;
  221.         }
  222.  
  223.         if (m_type != DT_STR)
  224.         {
  225.                 assert(false);
  226.                 pStr = "";
  227.                 return;
  228.         }
  229.  
  230.         uint16 rawVal;
  231.         m_Reader.ReadFromBufferEndianAware(GetDataAddr(), rawVal);
  232.         StringID stringId = rawVal;
  233.         pStr = m_Reader.GetStrDataTable().GetString(stringId);
  234. }
  235.  
  236. //////////////////////////////////////////////////////////////////////////
  237.  
  238. void CAttrReader::Get(float& val) const
  239. {
  240.         switch (m_type)
  241.         {
  242.         case DT_F1:
  243.                 {
  244.                         m_Reader.ReadFromBuffer(GetDataAddr(), val);
  245.                         break;
  246.                 }
  247.  
  248.         case DT_STR:
  249.                 {
  250.                         const char* pStr = NULL;
  251.                         Get(pStr);
  252.                         if (pStr)
  253.                                 val = float(atof(pStr));
  254.                         break;
  255.                 }
  256.  
  257.         case DT_F1_1DEC:
  258.                 {
  259.                         int8 byteVal;
  260.                         m_Reader.ReadFromBuffer(GetDataAddr(), byteVal);
  261.                         val = byteVal;
  262.                         val /= 10;
  263.                         break;
  264.                 }
  265.  
  266.         default:
  267.                 {
  268.                         int32 intVal;
  269.                         Get(intVal);
  270.                         val = float(intVal);
  271.                         break;
  272.                 }
  273.         }
  274. }
  275.  
  276. void CAttrReader::Get(Vec2& _val) const
  277. {
  278.         Vec3 val;
  279.         Get(val);
  280.         _val.x = val.x;
  281.         _val.y = val.y;
  282. }
  283.  
  284. void CAttrReader::Get(Ang3& _val) const
  285. {
  286.         Vec3 val;
  287.         Get(val);
  288.         _val.x = val.x;
  289.         _val.y = val.y;
  290.         _val.z = val.z;
  291. }
  292.  
  293. //////////////////////////////////////////////////////////////////////////
  294. // look at CAttrWriter::PackFloatInSemiConstType() for some explanation.
  295.  
  296. float CAttrReader::UnpackFloatInSemiConstType(uint8 mask, uint32 ind, FlatAddr& addr) const
  297. {
  298.         uint32 shift = ind * 2;
  299.  
  300.         uint32 type = (mask >> shift) & 3;
  301.  
  302.         switch (type)
  303.         {
  304.         case PFSC_0:
  305.                 return 0;
  306.         case PFSC_1:
  307.                 return 1;
  308.         case PFSC_N1:
  309.                 return -1;
  310.         case PFSC_VAL:
  311.                 {
  312.                         float val;
  313.                         addr = m_Reader.ReadFromBuffer(addr, val);
  314.                         return val;
  315.                 }
  316.         default:
  317.                 {
  318.                         assert(false);
  319.                         return 0;
  320.                 }
  321.         }
  322. }
  323.  
  324. void CAttrReader::Get(Vec3& val) const
  325. {
  326.         switch (m_type)
  327.         {
  328.         case DT_F3:
  329.                 {
  330.                         FlatAddr addr = m_Reader.ReadFromBuffer(GetDataAddr(), val.x);
  331.                         addr = m_Reader.ReadFromBuffer(addr, val.y);
  332.                         m_Reader.ReadFromBuffer(addr, val.z);
  333.                         break;
  334.                 }
  335.  
  336.         case DT_F3_1CONST:
  337.         case DT_F3_2CONST:
  338.         case DT_F3_3CONST:
  339.                 {
  340.                         uint8 mask;
  341.                         FlatAddr addr = m_Reader.ReadFromBuffer(GetDataAddr(), mask);
  342.                         val.x = UnpackFloatInSemiConstType(mask, 0, addr);
  343.                         val.y = UnpackFloatInSemiConstType(mask, 1, addr);
  344.                         val.z = UnpackFloatInSemiConstType(mask, 2, addr);
  345.                         break;
  346.                 }
  347.  
  348.         case DT_F3_100:
  349.                 {
  350.                         val.x = 1;
  351.                         val.y = 0;
  352.                         val.z = 0;
  353.                         break;
  354.                 }
  355.  
  356.         case DT_F3_010:
  357.                 {
  358.                         val.x = 0;
  359.                         val.y = 1;
  360.                         val.z = 0;
  361.                         break;
  362.                 }
  363.  
  364.         case DT_F3_001:
  365.                 {
  366.                         val.x = 0;
  367.                         val.y = 0;
  368.                         val.z = 1;
  369.                         break;
  370.                 }
  371.  
  372.         case DT_0:
  373.                 {
  374.                         val.x = val.y = val.z = 0;
  375.                         break;
  376.                 }
  377.  
  378.         default:
  379.                 {
  380.                         assert(false);
  381.                         break;
  382.                 }
  383.         }
  384. }
  385.  
  386. void CAttrReader::Get(Quat& val) const
  387. {
  388.         switch (m_type)
  389.         {
  390.         case DT_F4:
  391.                 {
  392.                         FlatAddr addr = m_Reader.ReadFromBuffer(GetDataAddr(), val.v.x);
  393.                         addr = m_Reader.ReadFromBuffer(addr, val.v.y);
  394.                         addr = m_Reader.ReadFromBuffer(addr, val.v.z);
  395.                         m_Reader.ReadFromBuffer(addr, val.w);
  396.                         break;
  397.                 }
  398.  
  399.         case DT_F4_1CONST:
  400.         case DT_F4_2CONST:
  401.         case DT_F4_3CONST:
  402.         case DT_F4_4CONST:
  403.                 {
  404.                         uint8 mask;
  405.                         FlatAddr addr = m_Reader.ReadFromBuffer(GetDataAddr(), mask);
  406.                         val.v.x = UnpackFloatInSemiConstType(mask, 0, addr);
  407.                         val.v.y = UnpackFloatInSemiConstType(mask, 1, addr);
  408.                         val.v.z = UnpackFloatInSemiConstType(mask, 2, addr);
  409.                         val.w = UnpackFloatInSemiConstType(mask, 3, addr);
  410.                         break;
  411.                 }
  412.  
  413.         case DT_0:
  414.                 {
  415.                         val.v.x = val.v.y = val.v.z = val.w = 0;
  416.                         break;
  417.                 }
  418.  
  419.         default:
  420.                 {
  421.                         assert(false);
  422.                         break;
  423.                 }
  424.         }
  425. }
  426.  
  427. void CAttrReader::Get(uint8*& rdata, uint32& outSize) const
  428. {
  429.         assert(m_type == DT_RAWDATA);
  430.  
  431.         // Read in the size of the raw chunk which follows
  432.         uint32 size;
  433.         FlatAddr addr = m_Reader.ReadFromBuffer(GetDataAddr(), size);
  434.  
  435.         // Realloc the buffer so it's large enough to handle the new data's size
  436.         rdata = (uint8*)realloc((void*)rdata, size * sizeof(uint8));
  437.         m_Reader.ReadFromBuffer(addr, rdata, size);
  438.         outSize = size;
  439. }
  440.  
  441. //////////////////////////////////////////////////////////////////////////
  442. // reads any attr value, converts to string and store it into an string
  443. // is separated from the normal Get functions in purpose: This function should be used only for error handling or other special situations
  444.  
  445. void CAttrReader::GetValueAsString(string& str) const
  446. {
  447.         switch (XMLCPB::GetBasicDataType(m_type))
  448.         {
  449.         case DT_STR:
  450.                 ValueToString<const char*>(str, "%s");
  451.                 break;
  452.  
  453.         case DT_INT32:
  454.                 ValueToString<uint32>(str, "%d");
  455.                 break;
  456.  
  457.         case DT_F1:
  458.                 ValueToString<float>(str, "%f");
  459.                 break;
  460.  
  461.         case DT_F3:
  462.                 {
  463.                         Vec3 val;
  464.                         Get(val);
  465.                         str.Format("%f,%f,%f", val.x, val.y, val.z);
  466.                         break;
  467.                 }
  468.  
  469.         case DT_F4:
  470.                 {
  471.                         Quat val;
  472.                         Get(val);
  473.                         str.Format("%f,%f,%f,%f", val.v.x, val.v.y, val.v.z, val.w);
  474.                         break;
  475.                 }
  476.  
  477.         case DT_INT64:
  478.                 ValueToString<uint64>(str, "%lu");
  479.                 break;
  480.  
  481.         case DT_RAWDATA:
  482.                 {
  483.                         uint32 size;
  484.                         m_Reader.ReadFromBuffer(GetDataAddr(), size);
  485.                         str.Format("RawData %u", size);
  486.                         break;
  487.                 }
  488.  
  489.         default:
  490.                 str = "";
  491.                 assert(false);
  492.                 break;
  493.         }
  494. }
  495.  
downloadXMLCPB_AttrReader.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