BVB Source Codes

CRYENGINE Show FeatureColor.cpp Source code

Return Download CRYENGINE: download FeatureColor.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  Created:     29/09/2014 by Filipe amim
  5. //  Description:
  6. // -------------------------------------------------------------------------
  7. //
  8. ////////////////////////////////////////////////////////////////////////////
  9.  
  10. #include "StdAfx.h"
  11. #include "ParticleSystem/ParticleEmitter.h"
  12. #include <CrySerialization/SmartPtr.h>
  13. #include "FeatureColor.h"
  14. #include "TimeSource.h"
  15.  
  16. CRY_PFX2_DBG
  17.  
  18. namespace pfx2
  19. {
  20.  
  21. EParticleDataType PDT(EPDT_Color, UCol, 1, BHasInit(true));
  22.  
  23. void IColorModifier::Serialize(Serialization::IArchive& ar)
  24. {
  25.         ar(m_enabled);
  26. }
  27.  
  28. CFeatureFieldColor::CFeatureFieldColor() : m_color(255, 255, 255), CParticleFeature(gpu_pfx2::eGpuFeatureType_Color) {}
  29.  
  30. void CFeatureFieldColor::AddToComponent(CParticleComponent* pComponent, SComponentParams* pParams)
  31. {
  32.         m_modInit.clear();
  33.         m_modUpdate.clear();
  34.  
  35.         pComponent->AddToUpdateList(EUL_InitUpdate, this);
  36.         pComponent->AddParticleData(EPDT_Color);
  37.  
  38.         for (auto& pModifier : m_modifiers)
  39.         {
  40.                 if (pModifier && pModifier->IsEnabled())
  41.                         pModifier->AddToParam(pComponent, this);
  42.         }
  43.         if (!m_modUpdate.empty())
  44.         {
  45.                 pComponent->AddParticleData(InitType(EPDT_Color));
  46.                 pComponent->AddToUpdateList(EUL_Update, this);
  47.         }
  48.  
  49.         if (auto pInt = GetGpuInterface())
  50.         {
  51.                 const int numSamples = gpu_pfx2::kNumModifierSamples;
  52.                 Vec3 samples[numSamples];
  53.                 Sample(samples, numSamples);
  54.                 gpu_pfx2::SFeatureParametersColorTable table;
  55.                 table.samples = samples;
  56.                 table.numSamples = numSamples;
  57.                 pInt->SetParameters(table);
  58.         }
  59. }
  60.  
  61. void CFeatureFieldColor::Serialize(Serialization::IArchive& ar)
  62. {
  63.         CParticleFeature::Serialize(ar);
  64.         SModParticleField modContext;
  65.         Serialization::SContext _modContext(ar, static_cast<IParamModContext*>(&modContext));
  66.         struct SerStruct
  67.         {
  68.                 SerStruct(std::vector<PColorModifier>& modifiers, ColorB& color)
  69.                         : m_modifiers(modifiers), m_color(color) {}
  70.                 void Serialize(Serialization::IArchive& ar)
  71.                 {
  72.                         ar(m_color, "Color", "^");
  73.                         ar(m_modifiers, "Modifiers", "^");
  74.                 }
  75.                 std::vector<PColorModifier>& m_modifiers;
  76.                 ColorB&                      m_color;
  77.         } serStruct(m_modifiers, m_color);
  78.         ar(serStruct, "Color", "Color");
  79. }
  80.  
  81. void CFeatureFieldColor::InitParticles(const SUpdateContext& context)
  82. {
  83.         CRY_PFX2_PROFILE_DETAIL;
  84.  
  85.         CParticleContainer& container = context.m_container;
  86.         IOColorStream colors = container.GetIOColorStream(EPDT_Color);
  87.  
  88.         UCol uColor;
  89.         uColor.dcolor = m_color.pack_argb8888() | 0xff000000;
  90.         UColv baseColor = ToUColv(uColor);
  91.         CRY_PFX2_FOR_SPAWNED_PARTICLEGROUP(context)
  92.         {
  93.                 colors.Store(particleGroupId, baseColor);
  94.         }
  95.         CRY_PFX2_FOR_END
  96.  
  97.         SUpdateRange spawnRange;
  98.         spawnRange.m_firstParticleId = context.m_container.GetFirstSpawnParticleId();
  99.         spawnRange.m_lastParticleId = context.m_container.GetLastParticleId();
  100.         for (auto& pModifier : m_modInit)
  101.                 pModifier->Modify(context, spawnRange, colors);
  102.  
  103.         container.CopyData(InitType(EPDT_Color), EPDT_Color, container.GetSpawnedRange());
  104. }
  105.  
  106. void CFeatureFieldColor::Update(const SUpdateContext& context)
  107. {
  108.         CRY_PFX2_PROFILE_DETAIL;
  109.  
  110.         CParticleContainer& container = context.m_container;
  111.         IOColorStream colors = container.GetIOColorStream(EPDT_Color);
  112.  
  113.         for (auto& pModifier : m_modUpdate)
  114.                 pModifier->Modify(context, context.m_updateRange, colors);
  115. }
  116.  
  117. void CFeatureFieldColor::AddToInitParticles(IColorModifier* pMod)
  118. {
  119.         if (std::find(m_modInit.begin(), m_modInit.end(), pMod) == m_modInit.end())
  120.                 m_modInit.push_back(pMod);
  121. }
  122.  
  123. void CFeatureFieldColor::AddToUpdate(IColorModifier* pMod)
  124. {
  125.         if (std::find(m_modInit.begin(), m_modInit.end(), pMod) == m_modInit.end())
  126.                 m_modUpdate.push_back(pMod);
  127. }
  128.  
  129. void CFeatureFieldColor::Sample(Vec3* samples, const int numSamples)
  130. {
  131.         Vec3 baseColor(m_color.r / 255.f, m_color.g / 255.f, m_color.b / 255.f);
  132.  
  133.         for (int i = 0; i < numSamples; ++i)
  134.                 samples[i] = baseColor;
  135.         for (auto& pModifier : m_modUpdate)
  136.                 pModifier->Sample(samples, numSamples);
  137. }
  138.  
  139. CRY_PFX2_IMPLEMENT_FEATURE(CParticleFeature, CFeatureFieldColor, "Field", "Color", colorField);
  140.  
  141. //////////////////////////////////////////////////////////////////////////
  142. // CColorRandom
  143.  
  144. class CColorRandom : public IColorModifier
  145. {
  146. public:
  147.  
  148.         virtual void AddToParam(CParticleComponent* pComponent, CFeatureFieldColor* pParam)
  149.         {
  150.                 pParam->AddToInitParticles(this);
  151.         }
  152.  
  153.         virtual void Serialize(Serialization::IArchive& ar)
  154.         {
  155.                 IColorModifier::Serialize(ar);
  156.                 ar(m_luminance, "Luminance", "Luminance");
  157.                 ar(m_rgb, "RGB", "RGB");
  158.         }
  159.  
  160.         virtual void Modify(const SUpdateContext& context, const SUpdateRange& range, IOColorStream stream) const
  161.         {
  162.                 CRY_PFX2_PROFILE_DETAIL;
  163.  
  164.                 if (m_luminance && m_rgb)
  165.                         DoModify<true, true>(context, range, stream);
  166.                 else if (m_luminance)
  167.                         DoModify<true, false>(context, range, stream);
  168.                 if (m_rgb)
  169.                         DoModify<false, true>(context, range, stream);
  170.         }
  171.  
  172. private:
  173.  
  174.         template<bool doLuminance, bool doRGB>
  175.         void DoModify(const SUpdateContext& context, const SUpdateRange& range, IOColorStream stream) const
  176.         {
  177.                 SChaosKeyV::Range randRange(1.0f - m_luminance, 1.0f);
  178.                 floatv rgb = ToFloatv(m_rgb),
  179.                        unrgb = ToFloatv(1.0f - m_rgb);
  180.  
  181.                 CRY_PFX2_FOR_RANGE_PARTICLESGROUP(range);
  182.                 {
  183.                         ColorFv color = ToColorFv(stream.Load(particleGroupId));
  184.                         if (doLuminance)
  185.                         {
  186.                                 const floatv lum = context.m_spawnRngv.Rand(randRange);
  187.                                 color = color * lum;
  188.                         }
  189.                         if (doRGB)
  190.                         {
  191.                                 ColorFv randColor(
  192.                                         context.m_spawnRngv.RandUNorm(),
  193.                                         context.m_spawnRngv.RandUNorm(),
  194.                                         context.m_spawnRngv.RandUNorm());
  195.                                 color = color * unrgb + randColor * rgb;
  196.                         }
  197.                         stream.Store(particleGroupId, ColorFvToUColv(color));
  198.                 }
  199.                 CRY_PFX2_FOR_END;
  200.         }
  201.  
  202.         UFloat m_luminance;
  203.         UFloat m_rgb;
  204. };
  205.  
  206. SERIALIZATION_CLASS_NAME(IColorModifier, CColorRandom, "ColorRandom", "Color Random");
  207.  
  208. //////////////////////////////////////////////////////////////////////////
  209. // CColorCurve
  210.  
  211. class CColorCurve : public CTimeSource, public IColorModifier
  212. {
  213. public:
  214.         virtual void AddToParam(CParticleComponent* pComponent, CFeatureFieldColor* pParam)
  215.         {
  216.                 if (m_spline.HasKeys())
  217.                         CTimeSource::AddToParam(pComponent, pParam, this);
  218.         }
  219.  
  220.         virtual void Serialize(Serialization::IArchive& ar)
  221.         {
  222.                 IColorModifier::Serialize(ar);
  223.                 CTimeSource::SerializeInplace(ar);
  224.                 string desc = ar.isEdit() ? GetSourceDescription() : "";
  225.                 Serialization::SContext _splineContext(ar, desc.data());
  226.                 ar(m_spline, "ColorCurve", "Color Curve");
  227.         }
  228.  
  229.         virtual void Modify(const SUpdateContext& context, const SUpdateRange& range, IOColorStream stream) const
  230.         {
  231.                 CRY_PFX2_PROFILE_DETAIL;
  232.                 CTimeSource::Dispatch<CColorCurve>(context, range, stream, EMD_PerParticle);
  233.         }
  234.  
  235.         template<typename TTimeKernel>
  236.         void DoModify(const SUpdateContext& context, const SUpdateRange& range, IOColorStream stream, const TTimeKernel& timeKernel) const
  237.         {
  238.                 CRY_PFX2_FOR_RANGE_PARTICLESGROUP(range);
  239.                 {
  240.                         const floatv sample = timeKernel.Sample(particleGroupId);
  241.                         const ColorFv color0 = ToColorFv(stream.Load(particleGroupId));
  242.                         const ColorFv curve = m_spline.Interpolate(sample);
  243.                         const ColorFv color1 = color0 * curve;
  244.                         stream.Store(particleGroupId, ColorFvToUColv(color1));
  245.                 }
  246.                 CRY_PFX2_FOR_END;
  247.         }
  248.  
  249.         virtual void Sample(Vec3* samples, int samplePoints) const
  250.         {
  251.                 for (int i = 0; i < samplePoints; ++i)
  252.                 {
  253.                         const float point = (float) i / samplePoints;
  254.                         Vec3 color0 = samples[i];
  255.                         ColorF curve = m_spline.Interpolate(point);
  256.                         Vec3 color1(color0.x * curve.r, color0.y * curve.g, color0.z * curve.b);
  257.                         samples[i] = color1;
  258.                 }
  259.         }
  260. private:
  261.         CParticleColorSpline m_spline;
  262. };
  263.  
  264. SERIALIZATION_CLASS_NAME(IColorModifier, CColorCurve, "ColorCurve", "Color Curve");
  265.  
  266. //////////////////////////////////////////////////////////////////////////
  267. // CColorAttribute
  268.  
  269. class CColorAttribute : public IColorModifier
  270. {
  271. public:
  272.         CColorAttribute()
  273.                 : m_scale(1.0f)
  274.                 , m_bias(0.0f)
  275.                 , m_gamma(1.0f)
  276.                 , m_spawnOnly(false) {}
  277.  
  278.         virtual void AddToParam(CParticleComponent* pComponent, CFeatureFieldColor* pParam)
  279.         {
  280.                 if (m_spawnOnly)
  281.                         pParam->AddToInitParticles(this);
  282.                 else
  283.                         pParam->AddToUpdate(this);
  284.         }
  285.  
  286.         virtual void Serialize(Serialization::IArchive& ar)
  287.         {
  288.                 IColorModifier::Serialize(ar);
  289.                 ar(m_name, "Name", "Attribute Name");
  290.                 ar(m_scale, "Scale", "Scale");
  291.                 ar(m_bias, "Bias", "Bias");
  292.                 ar(m_gamma, "Gamma", "Gamma");
  293.                 ar(m_spawnOnly, "SpawnOnly", "Spawn Only");
  294.         }
  295.  
  296.         virtual void Modify(const SUpdateContext& context, const SUpdateRange& range, IOColorStream stream) const
  297.         {
  298.                 CParticleContainer& container = context.m_container;
  299.                 const CAttributeInstance& attributes = context.m_runtime.GetEmitter()->GetAttributeInstance();
  300.                 auto attributeId = attributes.FindAttributeIdByName(m_name.c_str());
  301.                 ColorF attribute = attributes.GetAsColorF(attributeId, ColorF(1.0f, 1.0f, 1.0f));
  302.                 attribute.r = pow(attribute.r, m_gamma) * m_scale + m_bias;
  303.                 attribute.g = pow(attribute.g, m_gamma) * m_scale + m_bias;
  304.                 attribute.b = pow(attribute.b, m_gamma) * m_scale + m_bias;
  305.                 const ColorFv value = ToColorFv(attribute);
  306.  
  307.                 CRY_PFX2_FOR_RANGE_PARTICLESGROUP(range)
  308.                 {
  309.                         const ColorFv color0 = ToColorFv(stream.Load(particleGroupId));
  310.                         const ColorFv color1 = color0 * value;
  311.                         stream.Store(particleGroupId, ColorFvToUColv(color1));
  312.                 }
  313.                 CRY_PFX2_FOR_END;
  314.         }
  315.  
  316. private:
  317.         string m_name;
  318.         SFloat m_scale;
  319.         SFloat m_bias;
  320.         UFloat m_gamma;
  321.         bool   m_spawnOnly;
  322. };
  323.  
  324. SERIALIZATION_CLASS_NAME(IColorModifier, CColorAttribute, "Attribute", "Attribute");
  325.  
  326. //////////////////////////////////////////////////////////////////////////
  327. // CColorInherit
  328.  
  329. class CColorInherit : public IColorModifier
  330. {
  331. public:
  332.         CColorInherit()
  333.                 : m_spawnOnly(true) {}
  334.  
  335.         virtual void AddToParam(CParticleComponent* pComponent, CFeatureFieldColor* pParam)
  336.         {
  337.                 if (m_spawnOnly)
  338.                         pParam->AddToInitParticles(this);
  339.                 else
  340.                         pParam->AddToUpdate(this);
  341.         }
  342.  
  343.         virtual void Serialize(Serialization::IArchive& ar)
  344.         {
  345.                 IColorModifier::Serialize(ar);
  346.                 ar(m_spawnOnly, "SpawnOnly", "Spawn Only");
  347.         }
  348.  
  349.         virtual void Modify(const SUpdateContext& context, const SUpdateRange& range, IOColorStream stream) const
  350.         {
  351.                 CRY_PFX2_PROFILE_DETAIL;
  352.  
  353.                 CParticleContainer& container = context.m_container;
  354.                 CParticleContainer& parentContainer = context.m_parentContainer;
  355.                 if (!parentContainer.HasData(EPDT_Color))
  356.                         return;
  357.                 IPidStream parentIds = context.m_container.GetIPidStream(EPDT_ParentId);
  358.                 IColorStream parentColors = parentContainer.GetIColorStream(EPDT_Color);
  359.                 UCol defaultColor;
  360.                 defaultColor.dcolor = ~0u;
  361.  
  362.                 CRY_PFX2_FOR_RANGE_PARTICLESGROUP(range)
  363.                 {
  364.                         const TParticleIdv parentId = parentIds.Load(particleGroupId);
  365.                         const ColorFv color0 = ToColorFv(stream.Load(particleGroupId));
  366.                         const ColorFv parent = ToColorFv(parentColors.Load(parentId, defaultColor));
  367.                         const ColorFv color1 = color0 * parent;
  368.                         stream.Store(particleGroupId, ColorFvToUColv(color1));
  369.                 }
  370.                 CRY_PFX2_FOR_END;
  371.         }
  372.  
  373. private:
  374.         bool m_spawnOnly;
  375. };
  376.  
  377. SERIALIZATION_CLASS_NAME(IColorModifier, CColorInherit, "Inherit", "Inherit");
  378.  
  379. }
  380.  
downloadFeatureColor.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