BVB Source Codes

CRYENGINE Show ParticleAttributes.cpp Source code

Return Download CRYENGINE: download ParticleAttributes.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "ParticleCommon.h"
  5. #include "ParticleAttributes.h"
  6. #include "ParticleMath.h"
  7.  
  8. CRY_PFX2_DBG
  9.  
  10. namespace pfx2
  11. {
  12.  
  13. SERIALIZATION_ENUM_IMPLEMENT(EAttributeType);
  14. SERIALIZATION_ENUM_IMPLEMENT(EAttributeScope);
  15.  
  16. SAttribute::SAttribute()
  17.         : m_type(EAttributeType::Float)
  18.         , m_scope(EAttributeScope::PerEmitter)
  19.         , m_asColor(~0u)
  20.         , m_asInt(0)
  21.         , m_minInt(0)
  22.         , m_maxInt(10)
  23.         , m_asFloat(1.0f)
  24.         , m_minFloat(0.0f)
  25.         , m_maxFloat(1.0f)
  26.         , m_asBoolean(true)
  27.         , m_useMin(false)
  28.         , m_useMax(false)
  29. {
  30. }
  31.  
  32. void SAttribute::Serialize(Serialization::IArchive& ar)
  33. {
  34.         ar(m_type, "Type", "^>85>");
  35.         ar(m_name, "Name", "^");
  36.         ar(m_scope, "Scope", "Scope");
  37.         switch (m_type)
  38.         {
  39.         case EAttributeType::Boolean:
  40.                 ar(m_asBoolean, "Value", "^");
  41.                 break;
  42.         case EAttributeType::Integer:
  43.                 ar(m_asInt, "Value", "^");
  44.                 ar(m_useMin, "UseMin", "Use Min");
  45.                 ar(m_useMax, "UseMax", "Use Max");
  46.                 if (m_useMin)
  47.                         ar(m_minInt, "MinValue", "Minimum Value");
  48.                 if (m_useMax)
  49.                         ar(m_maxInt, "MaxValue", "Maximum Value");
  50.                 break;
  51.         case EAttributeType::Float:
  52.                 ar(m_asFloat, "Value", "^");
  53.                 ar(m_useMin, "UseMin", "Use Min");
  54.                 ar(m_useMax, "UseMax", "Use Max");
  55.                 if (m_useMin)
  56.                         ar(m_minFloat, "MinValue", "Minimum Value");
  57.                 if (m_useMax)
  58.                         ar(m_maxFloat, "MaxValue", "Maximum Value");
  59.                 break;
  60.         case EAttributeType::Color:
  61.                 ar(m_asColor, "Value", "^");
  62.                 break;
  63.         }
  64. }
  65.  
  66. //////////////////////////////////////////////////////////////////////////
  67.  
  68. void CAttributeTable::Serialize(Serialization::IArchive& ar)
  69. {
  70.         ar(m_attributes, "Attributes", "Attributes");
  71. }
  72.  
  73. //////////////////////////////////////////////////////////////////////////
  74.  
  75. CAttributeInstance::CAttributeInstance()
  76.         : m_pAttributeTable(nullptr)
  77. {
  78. }
  79.  
  80. void CAttributeInstance::Reset()
  81. {
  82.         m_attributeIndices.clear();
  83.         m_data.clear();
  84.         m_attributeIndices.shrink_to_fit();
  85.         m_data.shrink_to_fit();
  86.         m_pAttributeTable = nullptr;
  87. }
  88.  
  89. void CAttributeInstance::Reset(const CAttributeTable* pTable, EAttributeScope scope)
  90. {
  91.         CRY_PFX2_ASSERT(pTable != nullptr);
  92.  
  93.         m_pAttributeTable = pTable;
  94.  
  95.         m_attributeIndices.clear();
  96.         m_data.clear();
  97.  
  98.         for (size_t i = 0; i < pTable->GetNumAttributes(); ++i)
  99.         {
  100.                 const SAttribute& attribute = pTable->GetAttribute(i);
  101.                 if (attribute.m_scope != scope)
  102.                         continue;
  103.  
  104.                 SData data;
  105.                 switch (attribute.m_type)
  106.                 {
  107.                 case EAttributeType::Boolean:
  108.                         data.m_asBool = attribute.m_asBoolean;
  109.                         break;
  110.                 case EAttributeType::Integer:
  111.                         data.m_asInt = attribute.m_asInt;
  112.                         break;
  113.                 case EAttributeType::Float:
  114.                         data.m_asFloat = attribute.m_asFloat;
  115.                         break;
  116.                 case EAttributeType::Color:
  117.                         data.m_asColor.dcolor = attribute.m_asColor.pack_rgb888();
  118.                         break;
  119.                 }
  120.  
  121.                 m_attributeIndices.push_back(i);
  122.                 m_data.push_back(data);
  123.         }
  124. }
  125.  
  126. void CAttributeInstance::UpdateScriptTable(const SmartScriptTable& scriptTable)
  127. {
  128.         for (TAttributeId attributeId = 0; attributeId < m_attributeIndices.size(); ++attributeId)
  129.         {
  130.                 const SAttribute& attribute = GetAttribute(attributeId);
  131.                 if (attribute.m_scope != EAttributeScope::PerEmitter)
  132.                         continue;
  133.  
  134.                 switch (attribute.m_type)
  135.                 {
  136.                 case EAttributeType::Boolean:
  137.                         {
  138.                                 bool value = GetAsBoolean(attributeId, attribute.m_asBoolean);
  139.                                 if (scriptTable->GetValue(attribute.m_name.c_str(), value))
  140.                                         SetAsBoolean(attributeId, value);
  141.                                 else
  142.                                         scriptTable->SetValue(attribute.m_name.c_str(), value);
  143.                         }
  144.                         break;
  145.                 case EAttributeType::Float:
  146.                         {
  147.                                 float value = GetAsFloat(attributeId, attribute.m_asFloat);
  148.                                 if (scriptTable->GetValue(attribute.m_name.c_str(), value))
  149.                                         value = SetAsFloat(attributeId, value);
  150.                                 scriptTable->SetValue(attribute.m_name.c_str(), value);
  151.                         }
  152.                         break;
  153.                 case EAttributeType::Color:
  154.                         {
  155.                                 Vec3 value = GetAsColorF(attributeId, ColorF(attribute.m_asColor.toVec3())).toVec3();
  156.                                 if (scriptTable->GetValue(attribute.m_name.c_str(), value))
  157.                                         SetAsColor(attributeId, ColorF(value));
  158.                                 else
  159.                                         scriptTable->SetValue(attribute.m_name.c_str(), value);
  160.                         }
  161.                         break;
  162.                 }
  163.         }
  164. }
  165.  
  166. auto CAttributeInstance::FindAttributeIdByName(cstr name) const->TAttributeId
  167. {
  168.         auto it = std::find_if(
  169.           m_attributeIndices.begin(), m_attributeIndices.end(),
  170.           [this, name](const uint entryIndex)
  171.                 {
  172.                         const SAttribute& attribute = m_pAttributeTable->GetAttribute(entryIndex);
  173.                         return strcmp(name, attribute.m_name.c_str()) == 0;
  174.           });
  175.         if (it == m_attributeIndices.end())
  176.                 return gInvalidId;
  177.         return TAttributeId(it - m_attributeIndices.begin());
  178. }
  179.  
  180. uint CAttributeInstance::GetNumAttributes() const
  181. {
  182.         return uint(m_attributeIndices.size());
  183. }
  184.  
  185. cstr CAttributeInstance::GetAttributeName(uint idx) const
  186. {
  187.         if (idx >= m_attributeIndices.size())
  188.                 return nullptr;
  189.         return GetAttribute(m_attributeIndices[idx]).m_name.c_str();
  190. }
  191.  
  192. auto CAttributeInstance::GetAttributeType(uint idx) const->EType
  193. {
  194.         if (idx >= m_attributeIndices.size())
  195.                 return ET_Float;
  196.         return EType(GetAttribute(m_attributeIndices[idx]).m_type);
  197. }
  198.  
  199. const SAttribute& CAttributeInstance::GetAttribute(TAttributeId attributeId) const
  200. {
  201.         CRY_PFX2_ASSERT(attributeId < m_attributeIndices.size());
  202.         const uint entryIndex = m_attributeIndices[attributeId];
  203.         const SAttribute& attribute = m_pAttributeTable->GetAttribute(entryIndex);
  204.         return attribute;
  205. }
  206.  
  207. void CAttributeInstance::SetAsBoolean(TAttributeId id, bool value)
  208. {
  209.         if (id >= m_data.size())
  210.                 return;
  211.         const SAttribute& attribute = GetAttribute(id);
  212.         SData& data = m_data[id];
  213.         switch (attribute.m_type)
  214.         {
  215.         case EAttributeType::Boolean:
  216.                 data.m_asBool = value;
  217.                 break;
  218.         case EAttributeType::Integer:
  219.                 data.m_asInt = value ? 1 : 0;
  220.                 break;
  221.         case EAttributeType::Float:
  222.                 data.m_asFloat = value ? 1.0f : 0.0f;
  223.                 break;
  224.         case EAttributeType::Color:
  225.                 data.m_asColor.r = data.m_asColor.g = data.m_asColor.b = value ? 0xFF : 0x00;
  226.                 data.m_asColor.a = 0xff;
  227.                 break;
  228.         }
  229. }
  230.  
  231. bool CAttributeInstance::GetAsBoolean(TAttributeId id, bool defaultValue) const
  232. {
  233.         if (id >= m_data.size())
  234.                 return defaultValue;
  235.         const SAttribute& attribute = GetAttribute(id);
  236.         const SData& data = m_data[id];
  237.         switch (attribute.m_type)
  238.         {
  239.         case EAttributeType::Boolean:
  240.                 return data.m_asBool;
  241.         case EAttributeType::Integer:
  242.                 return data.m_asInt > 0 ? true : false;
  243.         case EAttributeType::Float:
  244.                 return data.m_asFloat > 0.0f ? true : false;
  245.         }
  246.         return defaultValue;
  247. }
  248.  
  249. int CAttributeInstance::SetAsInteger(TAttributeId id, int value)
  250. {
  251.         return value;
  252. }
  253.  
  254. int CAttributeInstance::GetAsInteger(TAttributeId id, int defaultValue) const
  255. {
  256.         return defaultValue;
  257. }
  258.  
  259. float CAttributeInstance::SetAsFloat(TAttributeId id, float value)
  260. {
  261.         if (id >= m_data.size())
  262.                 return value;
  263.  
  264.         const SAttribute& attribute = GetAttribute(id);
  265.         float actualValue = value;
  266.         if (attribute.m_useMin)
  267.                 actualValue = max(attribute.m_minFloat, actualValue);
  268.         if (attribute.m_useMax)
  269.                 actualValue = min(attribute.m_maxFloat, actualValue);
  270.  
  271.         SData& data = m_data[id];
  272.         switch (attribute.m_type)
  273.         {
  274.         case EAttributeType::Boolean:
  275.                 data.m_asBool = actualValue > 0.0f ? true : false;
  276.                 break;
  277.         case EAttributeType::Integer:
  278.                 data.m_asInt = int(actualValue);
  279.                 break;
  280.         case EAttributeType::Float:
  281.                 data.m_asFloat = value;
  282.                 break;
  283.         case EAttributeType::Color:
  284.                 data.m_asColor.r = data.m_asColor.g = data.m_asColor.b = float_to_ufrac8(actualValue);
  285.                 data.m_asColor.a = 0xff;
  286.                 break;
  287.         }
  288.  
  289.         return actualValue;
  290. }
  291.  
  292. float CAttributeInstance::GetAsFloat(TAttributeId id, float defaultValue) const
  293. {
  294.         if (id >= m_data.size())
  295.                 return defaultValue;
  296.         const SAttribute& attribute = GetAttribute(id);
  297.         const SData& data = m_data[id];
  298.         float result = defaultValue;
  299.         switch (attribute.m_type)
  300.         {
  301.         case EAttributeType::Boolean:
  302.                 result = data.m_asBool ? 1.0f : 0.0f;
  303.                 break;
  304.         case EAttributeType::Integer:
  305.                 result = float(data.m_asInt);
  306.                 break;
  307.         case EAttributeType::Float:
  308.                 result = data.m_asFloat;
  309.                 break;
  310.         case EAttributeType::Color:
  311.                 {
  312.                         const Vec3 colorv = attribute.m_asColor.toVec3();
  313.                         result = colorv.x * 0.299f + colorv.y * 0.587f + colorv.z * 0.114f;
  314.                 }
  315.         }
  316.         return result;
  317. }
  318.  
  319. void CAttributeInstance::SetAsColor(TAttributeId id, ColorB value)
  320. {
  321.         SetAsColor(id, ColorF(value.toVec3()));
  322. }
  323.  
  324. void CAttributeInstance::SetAsColor(TAttributeId id, ColorF value)
  325. {
  326.         if (id >= m_data.size())
  327.                 return;
  328.         const SAttribute& attribute = GetAttribute(id);
  329.         SData& data = m_data[id];
  330.         float brightness = value.r * 0.299f + value.g * 0.587f + value.b * 0.114f;
  331.         switch (attribute.m_type)
  332.         {
  333.         case EAttributeType::Boolean:
  334.                 data.m_asBool = (brightness > 0.0f);
  335.                 break;
  336.         case EAttributeType::Integer:
  337.                 data.m_asInt = int(brightness * 255.0f);
  338.                 break;
  339.         case EAttributeType::Float:
  340.                 data.m_asFloat = brightness;
  341.                 break;
  342.         case EAttributeType::Color:
  343.                 data.m_asColor = ColorFToUCol(value);
  344.                 break;
  345.         }
  346. }
  347.  
  348. ColorB CAttributeInstance::GetAsColorB(TAttributeId id, ColorB defaultValue) const
  349. {
  350.         return ColorB(GetAsColorF(id, ColorF(defaultValue.toVec3())));
  351. }
  352.  
  353. ColorF CAttributeInstance::GetAsColorF(TAttributeId id, ColorF defaultValue) const
  354. {
  355.         if (id >= m_data.size())
  356.                 return defaultValue;
  357.         const SAttribute& attribute = GetAttribute(id);
  358.         const SData& data = m_data[id];
  359.         switch (attribute.m_type)
  360.         {
  361.         case EAttributeType::Boolean:
  362.                 return data.m_asBool ? ColorF(1.0f, 1.0f, 1.0f) : ColorF(0.0f, 0.0f, 0.0f);
  363.         case EAttributeType::Integer:
  364.                 return ColorF(float(data.m_asInt), float(data.m_asInt), float(data.m_asInt)) / 255.0f;
  365.         case EAttributeType::Float:
  366.                 return ColorF(data.m_asFloat, data.m_asFloat, data.m_asFloat);
  367.         case EAttributeType::Color:
  368.                 return ToColorF(data.m_asColor);
  369.         }
  370.         return defaultValue;
  371. }
  372.  
  373. }
  374.  
downloadParticleAttributes.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