BVB Source Codes

CRYENGINE Show ParticleSpline.cpp Source code

Return Download CRYENGINE: download ParticleSpline.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  Created:     05/03/2015 by Filipe amim
  5. //  Description:
  6. // -------------------------------------------------------------------------
  7. //
  8. ////////////////////////////////////////////////////////////////////////////
  9.  
  10. #include "StdAfx.h"
  11. #include "ParticleCommon.h"
  12. #include "ParticleMath.h"
  13. #include "ParticleSpline.h"
  14. #include <CrySerialization/STL.h>
  15.  
  16.  
  17. namespace pfx2
  18. {
  19.  
  20.  
  21.         CParticleSpline::CParticleSpline()
  22.                 : m_valueRange(1.0f)
  23.         {
  24.                 MakeFlatLine(1.0f);
  25.         }
  26.  
  27.  
  28.         void CParticleSpline::MakeLinear(float v0, float v1)
  29.         {
  30.                 Resize(2);
  31.                 m_keys[0].time     = 0.0f;
  32.                 m_keys[1].time     = 1.0f;
  33.                 m_keys[0].value    = v0;
  34.                 m_keys[1].value    = v1;
  35.                 m_keys[0].timeMult = 1.0f;
  36.                 m_keys[0].coeff0   = m_keys[0].coeff1 = 0.0f;
  37.  
  38.                 m_valueRange = Range(Range::EMPTY) | v0 | v1;
  39.         }
  40.  
  41.  
  42.  
  43.  
  44.         bool CParticleSpline::FromString(cstr str)
  45.         {
  46.                 CSourceSpline spline;
  47.                 if (!spline.FromString(str))
  48.                         return false;
  49.                 FromSpline(spline);
  50.                 return true;
  51.         }
  52.  
  53.         bool CParticleSpline::Serialize(Serialization::IArchive& ar, const char* name, const char* label)
  54.         {
  55.                 if (!ar.isEdit() && ar.isOutput())
  56.                 {
  57.                         // On output, simplify identity spline
  58.                         if (m_valueRange == 1.0f)
  59.                         {
  60.                                 string str;
  61.                                 return !ar(str, name, label);
  62.                         }
  63.                 }
  64.                 return ISplineEvaluator::Serialize(ar, name, label);
  65.         }
  66.  
  67.         void CParticleSpline::FromSpline(const ISplineEvaluator& source)
  68.         {
  69.                 const size_t nKeys    = source.GetKeyCount();
  70.                 const size_t subNKeys = nKeys == 0 ? 0 : nKeys - 1;
  71.  
  72.                 KeyType key;
  73.                 if (nKeys >= 2)
  74.                 {
  75.                         Resize(nKeys);
  76.  
  77.                         m_valueRange = Range(Range::EMPTY);
  78.  
  79.                         for (size_t i = 0; i < nKeys; ++i)
  80.                         {
  81.                                 source.GetKey(i, key);
  82.                                 m_keys[i].time  = key.time;
  83.                                 m_keys[i].value = key.value[0];
  84.                                 m_valueRange   |= m_keys[i].value;
  85.                         }
  86.                         for (size_t i = 0; i < subNKeys; ++i)
  87.                         {
  88.                                 const float t0 = m_keys[i].time;
  89.                                 const float t1 = max(t0 + FLT_EPSILON, m_keys[i + 1].time);
  90.                                 const float v0 = m_keys[i].value;
  91.                                 const float v1 = m_keys[i + 1].value;
  92.                                 source.GetKey(i, key);
  93.                                 const float s0 = key.dd[0];
  94.                                 source.GetKey(i + 1, key);
  95.                                 const float s1 = key.ds[0];
  96.                                 const float dv = v1 - v0;
  97.  
  98.                                 m_keys[i].timeMult = 1.0f / (t1 - t0);
  99.                                 m_keys[i].coeff0   = s0 - dv;
  100.                                 m_keys[i].coeff1   = dv - s1;
  101.  
  102.                                 // Compute curve min/max
  103.                                 // v = v0 + s0 t + (-3v0 +3v1 -2s0 -s1) tt + (+2v0 -2v1 +s0 +s1) ttt
  104.                                 // v' = s0 + (-6v0 +6v1 -4s0 -2s1) t + (+6v0 -6v1 +3s0 +3s1) tt
  105.  
  106.                                 float roots[2];
  107.                                 int nRoots = solve_quadratic(
  108.                                     /* tt term */ 6.0f * (v0 - v1) + 3.0f * (s0 + s1),
  109.                                     /* t  term */ 6.0f * (v1 - v0) - 4.0f * s0 - 2.0f * s1,
  110.                                     /* 1  term */ s0,
  111.                                         roots);
  112.  
  113.                                 while (nRoots-- > 0)
  114.                                 {
  115.                                         const float t = roots[nRoots];
  116.                                         if (t > 0.0f && t < 1.0f)
  117.                                         {
  118.                                                 const float v = Interpolate(::Lerp(t0, t1, t));
  119.                                                 m_valueRange |= v;
  120.                                         }
  121.                                 }
  122.                         }
  123.                 }
  124.                 else
  125.                 {
  126.                         MakeFlatLine((nKeys == 1) ? (source.GetKey(0, key), key.value[0]) : 1.0f);
  127.                 }
  128.         }
  129.  
  130.  
  131.  
  132.         void CParticleSpline::Resize(size_t size)
  133.         {
  134.                 m_keys.resize(size);
  135.         }
  136.  
  137.         void CParticleSpline::GetKey(int i, KeyType& key) const
  138.         {
  139.                 key.time     = m_keys[i].time;
  140.                 key.value[0] = m_keys[i].value;
  141.  
  142.                 // Compute slopes.
  143.                 key.ds[0] = key.dd[0] = 0.0f;
  144.                 key.flags = 0;
  145.                 if (i > 0)
  146.                 {
  147.                         // In slope.
  148.                         key.ds[0]               = EndSlope(i - 1);
  149.                         key.flags.inTangentType = spline::ETangentType::Custom;
  150.                 }
  151.                 else
  152.                         //      key.flags.inTangentType = spline::ETangentType::Auto;
  153.                         key.flags.inTangentType = spline::ETangentType::Smooth;
  154.  
  155.                 if (i < GetKeyCount() - 1)
  156.                 {
  157.                         // Out slope.
  158.                         key.dd[0]                = StartSlope(i);
  159.                         key.flags.outTangentType = spline::ETangentType::Custom;
  160.                 }
  161.                 else
  162.                         //      key.flags.outTangentType = spline::ETangentType::Auto;
  163.                         key.flags.outTangentType = spline::ETangentType::Smooth;
  164.         }
  165.  
  166.  
  167.  
  168.         float CParticleSpline::DefaultSlope(size_t keyIdx) const
  169.         {
  170.                 const size_t numKeys = GetNumKeys();
  171.                 const bool isBorder  = keyIdx == 0 || keyIdx >= numKeys - 1;
  172.                 if (isBorder)
  173.                         return 0.0f;
  174.                 else
  175.                         return minmag(m_keys[keyIdx].value - m_keys[keyIdx - 1].value, m_keys[keyIdx + 1].value - m_keys[keyIdx].value);
  176.         }
  177.  
  178.  
  179.  
  180.         float CParticleSpline::StartSlope(size_t keyIdx) const
  181.         {
  182.                 return m_keys[keyIdx + 1].value - m_keys[keyIdx].value + m_keys[keyIdx].coeff0;
  183.         }
  184.  
  185.  
  186.  
  187.         float CParticleSpline::EndSlope(size_t keyIdx) const
  188.         {
  189.                 return m_keys[keyIdx + 1].value - m_keys[keyIdx].value - m_keys[keyIdx].coeff1;
  190.         }
  191.  
  192.  
  193.  
  194.  
  195. }
  196.  
  197.  
downloadParticleSpline.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