BVB Source Codes

CRYENGINE Show ScriptSerialize.cpp Source code

Return Download CRYENGINE: download ScriptSerialize.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.    Description: Helper classes for implementing serialization in script
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 24:11:2004   11:30 : Created by Craig Tiller
  12.  
  13. *************************************************************************/
  14. #include "StdAfx.h"
  15. #include "ScriptSerialize.h"
  16.  
  17. //
  18. // CScriptSerializeAny
  19. //
  20.  
  21. CScriptSerializeAny::CScriptSerializeAny(EScriptSerializeType type)
  22.         : m_type(type)
  23. {
  24.         m_buffer[0] = 0;
  25.  
  26.         switch (m_type)
  27.         {
  28.         case eSST_StringTable:
  29.         case eSST_String:
  30.                 new(Ptr<string>())string();
  31.                 break;
  32.         }
  33. }
  34.  
  35. CScriptSerializeAny::CScriptSerializeAny(const CScriptSerializeAny& other)
  36. {
  37.         m_type = other.m_type;
  38.         switch (m_type)
  39.         {
  40.         case eSST_StringTable:
  41.         case eSST_String:
  42.                 new(Ptr<string>())string(*other.Ptr<string>());
  43.                 break;
  44.  
  45.         default:
  46.                 memcpy(m_buffer, other.m_buffer, BUFFER_SIZE);
  47.         }
  48. }
  49.  
  50. CScriptSerializeAny::~CScriptSerializeAny()
  51. {
  52.         switch (m_type)
  53.         {
  54.         case eSST_StringTable:
  55.         case eSST_String:
  56.                 Ptr<string>()->~string();
  57.                 break;
  58.         }
  59. }
  60.  
  61. CScriptSerializeAny& CScriptSerializeAny::operator=(const CScriptSerializeAny& other)
  62. {
  63.         // this isn't general enough to be used in every place... but for what
  64.         // we have for now it should be fine
  65.         if (&other == this)
  66.                 return *this;
  67.         this->~CScriptSerializeAny();
  68.         new(this)CScriptSerializeAny(other);
  69.         return *this;
  70. }
  71.  
  72. bool CScriptSerializeAny::SetFromFunction(
  73.   IFunctionHandler* pFH,
  74.   int param)
  75. {
  76.         switch (m_type)
  77.         {
  78.         case eSST_Bool:
  79.                 if (!pFH->GetParam(param, *Ptr<bool>()))
  80.                         return false;
  81.                 break;
  82.         case eSST_Float:
  83.                 if (!pFH->GetParam(param, *Ptr<float>()))
  84.                         return false;
  85.                 break;
  86.         case eSST_Int8:
  87.                 {
  88.                         int temp;
  89.                         if (!pFH->GetParam(param, temp))
  90.                                 return false;
  91.                         *Ptr<int8>() = temp;
  92.                 }
  93.                 break;
  94.         case eSST_Int16:
  95.                 {
  96.                         int temp;
  97.                         if (!pFH->GetParam(param, temp))
  98.                                 return false;
  99.                         *Ptr<int16>() = temp;
  100.                 }
  101.                 break;
  102.         case eSST_Int32:
  103.                 {
  104.                         int temp;
  105.                         if (!pFH->GetParam(param, temp))
  106.                                 return false;
  107.                         *Ptr<int32>() = temp;
  108.                 }
  109.                 break;
  110.         case eSST_StringTable:
  111.         case eSST_String:
  112.                 {
  113.                         const char* temp;
  114.                         if (!pFH->GetParam(param, temp))
  115.                                 return false;
  116.                         *Ptr<string>() = temp;
  117.                 }
  118.                 break;
  119.         case eSST_EntityId:
  120.                 {
  121.                         ScriptHandle temp;
  122.                         if (!pFH->GetParam(param, temp))
  123.                                 return false;
  124.                         *Ptr<EntityId>() = (EntityId)temp.n;
  125.                 }
  126.                 break;
  127.         case eSST_Vec3:
  128.                 {
  129.                         Vec3 temp;
  130.                         if (!pFH->GetParam(param, temp))
  131.                                 return false;
  132.                         *Ptr<Vec3>() = temp;
  133.                 }
  134.         case eSST_Void:
  135.                 break;
  136.         default:
  137.                 CRY_ASSERT(!"need to add the type enum to this switch");
  138.         }
  139.         return true;
  140. }
  141.  
  142. void CScriptSerializeAny::PushFuncParam(IScriptSystem* pSS) const
  143. {
  144.         switch (m_type)
  145.         {
  146.         case eSST_Bool:
  147.                 pSS->PushFuncParam(*Ptr<bool>());
  148.                 break;
  149.         case eSST_Float:
  150.                 pSS->PushFuncParam(*Ptr<float>());
  151.                 break;
  152.         case eSST_Int8:
  153.                 pSS->PushFuncParam((int)*Ptr<int8>());
  154.                 break;
  155.         case eSST_Int16:
  156.                 pSS->PushFuncParam((int)*Ptr<int16>());
  157.                 break;
  158.         case eSST_Int32:
  159.                 pSS->PushFuncParam((int)*Ptr<int32>());
  160.                 break;
  161.         case eSST_StringTable:
  162.         case eSST_String:
  163.                 pSS->PushFuncParam(Ptr<string>()->c_str());
  164.                 break;
  165.         case eSST_EntityId:
  166.                 {
  167.                         ScriptHandle temp;
  168.                         temp.n = *Ptr<EntityId>();
  169.                         pSS->PushFuncParam(temp);
  170.                 }
  171.                 break;
  172.         case eSST_Vec3:
  173.                 pSS->PushFuncParam(*Ptr<Vec3>());
  174.                 break;
  175.         case eSST_Void:
  176.                 pSS->PushFuncParam(0);
  177.                 break;
  178.         default:
  179.                 CRY_ASSERT(!"need to add the type enum to this switch");
  180.         }
  181. }
  182.  
  183. void CScriptSerializeAny::SerializeWith(TSerialize ser, const char* name)
  184. {
  185. #define SER_NAME(n) (name ? name : n)
  186.  
  187.         switch (m_type)
  188.         {
  189.         case eSST_Bool:
  190.                 ser.Value(SER_NAME("bool"), *Ptr<bool>());
  191.                 break;
  192.         case eSST_Float:
  193.                 ser.Value(SER_NAME("float"), *Ptr<float>());
  194.                 break;
  195.         case eSST_Int8:
  196.                 ser.Value(SER_NAME("int8"), *Ptr<int8>());
  197.                 break;
  198.         case eSST_Int16:
  199.                 ser.Value(SER_NAME("int16"), *Ptr<int16>());
  200.                 break;
  201.         case eSST_Int32:
  202.                 ser.Value(SER_NAME("int32"), *Ptr<int32>());
  203.                 break;
  204.         case eSST_String:
  205.                 ser.Value(SER_NAME("string"), *Ptr<string>());
  206.                 break;
  207.         case eSST_StringTable:
  208.                 ser.Value(SER_NAME("string"), *Ptr<string>(), 'stab');
  209.                 break;
  210.         case eSST_EntityId:
  211.                 ser.Value(SER_NAME("entityid"), *Ptr<EntityId>(), 'eid');
  212.                 break;
  213.         case eSST_Vec3:
  214.                 ser.Value(SER_NAME("vec3"), *Ptr<Vec3>());
  215.                 break;
  216.         case eSST_Void:
  217.                 break;
  218.         default:
  219.                 CRY_ASSERT(!"need to add the type enum to this switch");
  220.         }
  221.  
  222. #undef SER_NAME
  223. }
  224.  
  225. bool CScriptSerializeAny::CopyFromTable(SmartScriptTable& tbl, const char* name)
  226. {
  227.         bool ok = false;
  228.  
  229.         switch (m_type)
  230.         {
  231.         case eSST_Bool:
  232.                 ok = tbl->GetValue(name, *Ptr<bool>());
  233.                 break;
  234.         case eSST_Float:
  235.                 ok = tbl->GetValue(name, *Ptr<float>());
  236.                 break;
  237.         case eSST_Int8:
  238.                 {
  239.                         int temp;
  240.                         ok = tbl->GetValue(name, temp);
  241.                         *Ptr<int8>() = temp;
  242.                 }
  243.                 break;
  244.         case eSST_Int16:
  245.                 {
  246.                         int temp;
  247.                         ok = tbl->GetValue(name, temp);
  248.                         *Ptr<int16>() = temp;
  249.                 }
  250.                 break;
  251.         case eSST_Int32:
  252.                 {
  253.                         int temp;
  254.                         ok = tbl->GetValue(name, temp);
  255.                         *Ptr<int32>() = temp;
  256.                 }
  257.                 break;
  258.         case eSST_StringTable:
  259.         case eSST_String:
  260.                 {
  261.                         const char* temp;
  262.                         ok = tbl->GetValue(name, temp);
  263.                         *Ptr<string>() = temp;
  264.                 }
  265.                 break;
  266.         case eSST_EntityId:
  267.                 {
  268.                         ScriptHandle temp;
  269.                         ok = tbl->GetValue(name, temp);
  270.                         *Ptr<EntityId>() = (EntityId)temp.n;
  271.                 }
  272.                 break;
  273.         case eSST_Vec3:
  274.                 {
  275.                         Vec3 temp;
  276.                         ok = tbl->GetValue(name, temp);
  277.                         *Ptr<Vec3>() = temp;
  278.                 }
  279.                 break;
  280.         case eSST_Void:
  281.                 ok = true;
  282.                 break;
  283.         default:
  284.                 CRY_ASSERT(!"need to add the type enum to this switch");
  285.         }
  286.  
  287.         if (!ok)
  288.                 GameWarning("Unable to read property %s of type %c", name, (char)m_type);
  289.  
  290.         return ok;
  291. }
  292.  
  293. void CScriptSerializeAny::CopyToTable(SmartScriptTable& tbl, const char* name)
  294. {
  295.         switch (m_type)
  296.         {
  297.         case eSST_Bool:
  298.                 tbl->SetValue(name, *Ptr<bool>());
  299.                 break;
  300.         case eSST_Float:
  301.                 tbl->SetValue(name, *Ptr<float>());
  302.                 break;
  303.         case eSST_Int8:
  304.                 tbl->SetValue(name, (int)*Ptr<int8>());
  305.                 break;
  306.         case eSST_Int16:
  307.                 tbl->SetValue(name, (int)*Ptr<int16>());
  308.                 break;
  309.         case eSST_Int32:
  310.                 tbl->SetValue(name, (int)*Ptr<int32>());
  311.                 break;
  312.         case eSST_StringTable:
  313.         case eSST_String:
  314.                 tbl->SetValue(name, Ptr<string>()->c_str());
  315.                 break;
  316.         case eSST_EntityId:
  317.                 {
  318.                         ScriptHandle temp;
  319.                         temp.n = *Ptr<EntityId>();
  320.                         tbl->SetValue(name, temp);
  321.                 }
  322.                 break;
  323.         case eSST_Vec3:
  324.                 tbl->SetValue(name, *Ptr<Vec3>());
  325.                 break;
  326.         case eSST_Void:
  327.                 tbl->SetToNull(name);
  328.                 break;
  329.         default:
  330.                 CRY_ASSERT(!"need to add the type enum to this switch");
  331.         }
  332. }
  333.  
  334. string CScriptSerializeAny::DebugInfo() const
  335. {
  336.         string output;
  337.  
  338.         switch (m_type)
  339.         {
  340.         case eSST_Bool:
  341.                 output = *Ptr<bool>() ? "true" : "false";
  342.                 break;
  343.         case eSST_Float:
  344.                 output.Format("%f", *Ptr<float>());
  345.                 break;
  346.         case eSST_Int8:
  347.                 output.Format("%i", (int)*Ptr<int8>());
  348.                 break;
  349.         case eSST_Int16:
  350.                 output.Format("%i", (int)*Ptr<int16>());
  351.                 break;
  352.         case eSST_Int32:
  353.                 output.Format("%i", (int)*Ptr<int32>());
  354.                 break;
  355.         case eSST_StringTable:
  356.         case eSST_String:
  357.                 output = *Ptr<string>();
  358.                 break;
  359.         case eSST_EntityId:
  360.                 {
  361.                         EntityId id = *Ptr<EntityId>();
  362.                         IEntity* pEntity = gEnv->pEntitySystem->GetEntity(id);
  363.                         const char* name = pEntity ? pEntity->GetName() : "<no such entity>";
  364.                         output.Format("entity[%u]:%s", id, name);
  365.                 }
  366.                 break;
  367.         case eSST_Vec3:
  368.                 {
  369.                         Vec3 temp = *Ptr<Vec3>();
  370.                         output.Format("%f,%f,%f", temp.x, temp.y, temp.z);
  371.                 }
  372.                 break;
  373.         case eSST_Void:
  374.                 output = "void";
  375.                 break;
  376.         default:
  377.                 CRY_ASSERT(!"need to add the type enum to this switch");
  378.         }
  379.  
  380.         return output;
  381. }
  382.  
  383. //
  384. // CScriptRMISerialize
  385. //
  386.  
  387. CScriptRMISerialize::CScriptRMISerialize(const char* format)
  388. {
  389.         while (*format)
  390.         {
  391.                 m_values.push_back((EScriptSerializeType) * format);
  392.                 format++;
  393.         }
  394. }
  395.  
  396. void CScriptRMISerialize::SerializeWith(TSerialize ser)
  397. {
  398.         for (TValueVec::iterator i = m_values.begin(); i != m_values.end(); ++i)
  399.         {
  400.                 i->SerializeWith(ser);
  401.         }
  402. }
  403.  
  404. bool CScriptRMISerialize::SetFromFunction(
  405.   IFunctionHandler* pFH,
  406.   int firstParam)
  407. {
  408.         for (size_t i = 0; i < m_values.size(); i++)
  409.         {
  410.                 if (!m_values[i].SetFromFunction(pFH, firstParam + i))
  411.                         return false;
  412.         }
  413.         return true;
  414. }
  415.  
  416. void CScriptRMISerialize::PushFunctionParams(IScriptSystem* pSS)
  417. {
  418.         for (TValueVec::iterator i = m_values.begin(); i != m_values.end(); ++i)
  419.         {
  420.                 i->PushFuncParam(pSS);
  421.         }
  422. }
  423.  
  424. string CScriptRMISerialize::DebugInfo()
  425. {
  426.         bool first = true;
  427.         string out;
  428.         for (TValueVec::iterator i = m_values.begin(); i != m_values.end(); ++i)
  429.         {
  430.                 if (!first)
  431.                         out += ", ";
  432.                 out += i->DebugInfo();
  433.                 first = false;
  434.         }
  435.         return out;
  436. }
  437.  
  438. //
  439. // CScriptSerialize
  440. //
  441.  
  442. bool CScriptSerialize::ReadValue(const char* name, EScriptSerializeType type, TSerialize ser, IScriptTable* pTable)
  443. {
  444.         switch (type)
  445.         {
  446.         case eSST_Bool:
  447.                 {
  448.                         bool temp;
  449.                         ser.Value(name, temp /*, 'bool'*/);
  450.                         pTable->SetValue(name, temp);
  451.                 }
  452.                 break;
  453.         case eSST_Float:
  454.                 {
  455.                         float temp;
  456.                         ser.Value(name, temp);
  457.                         pTable->SetValue(name, temp);
  458.                 }
  459.                 break;
  460.         case eSST_Int8:
  461.                 {
  462.                         int8 temp;
  463.                         ser.Value(name, temp, 'i8');
  464.                         pTable->SetValue(name, (int)temp);
  465.                 }
  466.                 break;
  467.         case eSST_Int16:
  468.                 {
  469.                         int16 temp;
  470.                         ser.Value(name, temp, 'i16');
  471.                         pTable->SetValue(name, (int)temp);
  472.                 }
  473.                 break;
  474.         case eSST_Int32:
  475.                 {
  476.                         int32 temp;
  477.                         ser.Value(name, temp, 'i32');
  478.                         pTable->SetValue(name, (int)temp);
  479.                 }
  480.                 break;
  481.         case eSST_String:
  482.                 {
  483.                         ser.Value(name, m_tempString);
  484.                         pTable->SetValue(name, m_tempString.c_str());
  485.                 }
  486.                 break;
  487.         case eSST_StringTable:
  488.                 {
  489.                         ser.Value(name, m_tempString, 'stab');
  490.                         pTable->SetValue(name, m_tempString.c_str());
  491.                 }
  492.                 break;
  493.         case eSST_EntityId:
  494.                 {
  495.                         EntityId id;
  496.                         ScriptHandle hdl;
  497.                         ser.Value(name, id, 'eid');
  498.                         hdl.n = id;
  499.                         pTable->SetValue(name, hdl);
  500.                 }
  501.                 break;
  502.         case eSST_Vec3:
  503.                 {
  504.                         Vec3 temp;
  505.                         ser.Value(name, temp);
  506.                         pTable->SetValue(name, temp);
  507.                 }
  508.                 break;
  509.         default:
  510.                 CRY_ASSERT(!"type not added to ReadValue");
  511.                 return false;
  512.         }
  513.         return true;
  514. }
  515.  
  516. bool CScriptSerialize::WriteValue(const char* name, EScriptSerializeType type, TSerialize ser, IScriptTable* pTable)
  517. {
  518.         bool ok = false;
  519.         switch (type)
  520.         {
  521.         case eSST_Bool:
  522.                 {
  523.                         bool temp = false;
  524.                         if (ok = pTable->GetValue(name, temp))
  525.                                 ser.Value(name, temp /*, 'bool'*/);
  526.                         else if (!pTable->HaveValue(name))
  527.                         {
  528.                                 ser.Value(name, temp);
  529.                                 ok = true;
  530.                         }
  531.                 }
  532.                 break;
  533.         case eSST_Float:
  534.                 {
  535.                         float temp = 0;
  536.                         if (ok = pTable->GetValue(name, temp))
  537.                                 ser.Value(name, temp);
  538.                         else if (!pTable->HaveValue(name))
  539.                         {
  540.                                 ser.Value(name, temp);
  541.                                 ok = true;
  542.                         }
  543.                 }
  544.                 break;
  545.         case eSST_Int8:
  546.                 {
  547.                         int temp1;
  548.                         int8 temp2 = 0;
  549.                         if (ok = pTable->GetValue(name, temp1))
  550.                         {
  551.                                 if (temp1 < -128 || temp1 > 127)
  552.                                         ok = false;
  553.                                 else
  554.                                 {
  555.                                         temp2 = temp1;
  556.                                         ser.Value(name, temp2, 'i8');
  557.                                 }
  558.                         }
  559.                         else if (!pTable->HaveValue(name))
  560.                         {
  561.                                 ser.Value(name, temp2, 'i8');
  562.                                 ok = true;
  563.                         }
  564.                 }
  565.                 break;
  566.         case eSST_Int16:
  567.                 {
  568.                         int temp1;
  569.                         int16 temp2 = 0;
  570.                         if (ok = pTable->GetValue(name, temp1))
  571.                         {
  572.                                 if (temp1 < -32768 || temp1 > 32767)
  573.                                         ok = false;
  574.                                 else
  575.                                 {
  576.                                         temp2 = temp1;
  577.                                         ser.Value(name, temp2, 'i16');
  578.                                 }
  579.                         }
  580.                         else if (!pTable->HaveValue(name))
  581.                         {
  582.                                 ser.Value(name, temp2, 'i16');
  583.                                 ok = true;
  584.                         }
  585.                 }
  586.                 break;
  587.         case eSST_Int32:
  588.                 {
  589.                         int32 temp1;
  590.                         int temp2 = 0;
  591.                         if (ok = pTable->GetValue(name, temp1))
  592.                         {
  593.                                 temp2 = temp1;
  594.                                 ser.Value(name, temp2, 'i32');
  595.                         }
  596.                         else if (!pTable->HaveValue(name))
  597.                         {
  598.                                 ser.Value(name, temp2, 'i32');
  599.                                 ok = true;
  600.                         }
  601.                 }
  602.                 break;
  603.         case eSST_StringTable:
  604.         case eSST_String:
  605.                 {
  606.                         const char* temp;
  607.                         if (ok = pTable->GetValue(name, temp))
  608.                         {
  609.                                 m_tempString = temp;
  610.                                 ser.Value(name, m_tempString);
  611.                         }
  612.                         else if (!pTable->HaveValue(name))
  613.                         {
  614.                                 m_tempString = string();
  615.                                 ser.Value(name, m_tempString);
  616.                                 ok = true;
  617.                         }
  618.                 }
  619.                 break;
  620.         case eSST_EntityId:
  621.                 {
  622.                         EntityId id = 0;
  623.                         ScriptHandle hdl;
  624.                         if (ok = pTable->GetValue(name, hdl))
  625.                         {
  626.                                 id = (EntityId)hdl.n;
  627.                                 ser.Value(name, id, 'eid');
  628.                         }
  629.                         else if (!pTable->HaveValue(name))
  630.                         {
  631.                                 ser.Value(name, id, 'eid');
  632.                                 ok = true;
  633.                         }
  634.                 }
  635.                 break;
  636.         case eSST_Vec3:
  637.                 {
  638.                         Vec3 temp = ZERO;
  639.                         if (ok = pTable->GetValue(name, temp))
  640.                         {
  641.                                 ser.Value(name, temp);
  642.                         }
  643.                         else if (!pTable->HaveValue(name))
  644.                         {
  645.                                 ser.Value(name, temp);
  646.                                 ok = true;
  647.                         }
  648.                 }
  649.         default:
  650.                 CRY_ASSERT(!"type not added to WriteValue");
  651.                 ok = false;
  652.         }
  653.         return ok;
  654. }
  655.  
downloadScriptSerialize.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