BVB Source Codes

CRYENGINE Show FeatureVelocity.cpp Source code

Return Download CRYENGINE: download FeatureVelocity.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/10/2014 by Filipe amim
  5. //  Description:
  6. // -------------------------------------------------------------------------
  7. //
  8. ////////////////////////////////////////////////////////////////////////////
  9.  
  10. #include "StdAfx.h"
  11. #include <CrySerialization/Math.h>
  12. #include "ParticleSystem/ParticleFeature.h"
  13. #include "ParticleSystem/ParticleEmitter.h"
  14. #include "ParamMod.h"
  15.  
  16. CRY_PFX2_DBG
  17.  
  18. namespace pfx2
  19. {
  20.  
  21. class CFeatureVelocityCone : public CParticleFeature
  22. {
  23. public:
  24.         CRY_PFX2_DECLARE_FEATURE
  25.  
  26.         CFeatureVelocityCone()
  27.                 : m_velocity(0.0f)
  28.                 , m_angle(0.0f)
  29.                 , CParticleFeature(gpu_pfx2::eGpuFeatureType_VelocityCone)
  30.         {}
  31.  
  32.         virtual void AddToComponent(CParticleComponent* pComponent, SComponentParams* pParams) override
  33.         {
  34.                 pComponent->AddToUpdateList(EUL_InitUpdate, this);
  35.                 m_angle.AddToComponent(pComponent, this);
  36.                 m_velocity.AddToComponent(pComponent, this);
  37.  
  38.                 if (auto pInt = GetGpuInterface())
  39.                 {
  40.                         gpu_pfx2::SFeatureParametersVelocityCone params;
  41.                         params.angle = m_angle.GetBaseValue();
  42.                         params.velocity = m_velocity.GetBaseValue();
  43.                         pInt->SetParameters(params);
  44.                 }
  45.         }
  46.  
  47.         virtual void Serialize(Serialization::IArchive& ar) override
  48.         {
  49.                 CParticleFeature::Serialize(ar);
  50.                 ar(m_angle, "Angle", "Angle");
  51.                 ar(m_velocity, "Velocity", "Velocity");
  52.         }
  53.  
  54.         virtual void InitParticles(const SUpdateContext& context) override
  55.         {
  56.                 CRY_PFX2_PROFILE_DETAIL;
  57.  
  58.                 CParticleContainer& parentContainer = context.m_parentContainer;
  59.                 CParticleContainer& container = context.m_container;
  60.                 const Quat defaultQuat = context.m_runtime.GetEmitter()->GetLocation().q;
  61.                 IPidStream parentIds = container.GetIPidStream(EPDT_ParentId);
  62.                 IQuatStream parentQuats = parentContainer.GetIQuatStream(EPQF_Orientation, defaultQuat);
  63.                 IOVec3Stream velocities = container.GetIOVec3Stream(EPVF_Velocity);
  64.                 const float baseAngle = m_angle.GetBaseValue();
  65.                 const float invBaseAngle = rcp_fast(max(FLT_EPSILON, baseAngle));
  66.  
  67.                 STempModBuffer angles(context, m_angle);
  68.                 STempModBuffer velocityMults(context, m_velocity);
  69.                 angles.ModifyInit(context, m_angle, container.GetSpawnedRange());
  70.                 velocityMults.ModifyInit(context, m_velocity, container.GetSpawnedRange());
  71.  
  72.                 CRY_PFX2_FOR_SPAWNED_PARTICLES(context)
  73.                 {
  74.                         const TParticleId parentId = parentIds.Load(particleId);
  75.                         const Vec3 wVelocity0 = velocities.Load(particleId);
  76.                         const Quat wQuat = parentQuats.SafeLoad(parentId);
  77.                         const float angleMult = angles.m_stream.SafeLoad(particleId);
  78.                         const float velocity = velocityMults.m_stream.SafeLoad(particleId);
  79.  
  80.                         const Vec2 disc = context.m_spawnRng.RandCircle();
  81.                         const float angle = sqrtf(angleMult * invBaseAngle) * baseAngle;
  82.  
  83.                         float as, ac;
  84.                         sincos(angle, &as, &ac);
  85.                         const Vec3 dir = Vec3(disc.x * as, disc.y * as, ac);
  86.                         const Vec3 oVelocity = dir * velocity;
  87.                         const Vec3 wVelocity1 = wVelocity0 + wQuat * oVelocity;
  88.                         velocities.Store(particleId, wVelocity1);
  89.                 }
  90.                 CRY_PFX2_FOR_END;
  91.         }
  92.  
  93. private:
  94.         CParamMod<SModParticleSpawnInit, UAngle180> m_angle;
  95.         CParamMod<SModParticleSpawnInit, UFloat10>  m_velocity;
  96. };
  97.  
  98. CRY_PFX2_IMPLEMENT_FEATURE(CParticleFeature, CFeatureVelocityCone, "Velocity", "Cone", colorVelocity);
  99.  
  100. //////////////////////////////////////////////////////////////////////////
  101.  
  102. class CFeatureVelocityDirectional : public CParticleFeature
  103. {
  104. public:
  105.         CRY_PFX2_DECLARE_FEATURE
  106.  
  107.         CFeatureVelocityDirectional()
  108.                 : m_direction(ZERO)
  109.                 , m_scale(1.0f)
  110.                 , CParticleFeature(gpu_pfx2::eGpuFeatureType_VelocityDirectional)
  111.         {}
  112.  
  113.         virtual void AddToComponent(CParticleComponent* pComponent, SComponentParams* pParams) override
  114.         {
  115.                 pComponent->AddToUpdateList(EUL_InitUpdate, this);
  116.                 m_scale.AddToComponent(pComponent, this);
  117.  
  118.                 if (auto pGpu = GetGpuInterface())
  119.                 {
  120.                         gpu_pfx2::SFeatureParametersVelocityDirectional params;
  121.                         params.direction = m_direction;
  122.                         params.scale = m_scale.GetBaseValue();
  123.                         pGpu->SetParameters(params);
  124.                 }
  125.         }
  126.  
  127.         virtual void Serialize(Serialization::IArchive& ar) override
  128.         {
  129.                 CParticleFeature::Serialize(ar);
  130.                 ar(m_direction, "Velocity", "Velocity");
  131.                 ar(m_scale, "Scale", "Scale");
  132.         }
  133.  
  134.         virtual void InitParticles(const SUpdateContext& context) override
  135.         {
  136.                 CRY_PFX2_PROFILE_DETAIL;
  137.  
  138.                 CParticleContainer& parentContainer = context.m_parentContainer;
  139.                 CParticleContainer& container = context.m_container;
  140.                 const Quat defaultQuat = context.m_runtime.GetEmitter()->GetLocation().q;
  141.                 IPidStream parentIds = container.GetIPidStream(EPDT_ParentId);
  142.                 IOVec3Stream velocities = container.GetIOVec3Stream(EPVF_Velocity);
  143.                 IQuatStream parentQuats = parentContainer.GetIQuatStream(EPQF_Orientation, defaultQuat);
  144.                 STempModBuffer scales(context, m_scale);
  145.                 scales.ModifyInit(context, m_scale, container.GetSpawnedRange());
  146.  
  147.                 CRY_PFX2_FOR_SPAWNED_PARTICLES(context)
  148.                 {
  149.                         const TParticleId parentId = parentIds.Load(particleId);
  150.                         const Quat wQuat = parentQuats.SafeLoad(parentId);
  151.                         const float scale = scales.m_stream.SafeLoad(particleId);
  152.                         const Vec3 wVelocity0 = velocities.Load(particleId);
  153.                         const Vec3 oVelocity = m_direction * scale;
  154.                         const Vec3 wVelocity1 = wVelocity0 + wQuat * oVelocity;
  155.                         velocities.Store(particleId, wVelocity1);
  156.                 }
  157.                 CRY_PFX2_FOR_END;
  158.         }
  159.  
  160. private:
  161.         Vec3 m_direction;
  162.         CParamMod<SModParticleSpawnInit, UFloat10> m_scale;
  163. };
  164.  
  165. CRY_PFX2_IMPLEMENT_FEATURE(CParticleFeature, CFeatureVelocityDirectional, "Velocity", "Directional", colorVelocity);
  166.  
  167. //////////////////////////////////////////////////////////////////////////
  168.  
  169. class CFeatureVelocityOmniDirectional : public CParticleFeature
  170. {
  171. public:
  172.         CRY_PFX2_DECLARE_FEATURE
  173.  
  174.         CFeatureVelocityOmniDirectional()
  175.                 : m_velocity(0.0f)
  176.                 , CParticleFeature(gpu_pfx2::eGpuFeatureType_VelocityOmniDirectional)
  177.         {}
  178.  
  179.         virtual void AddToComponent(CParticleComponent* pComponent, SComponentParams* pParams) override
  180.         {
  181.                 pComponent->AddToUpdateList(EUL_InitUpdate, this);
  182.                 m_velocity.AddToComponent(pComponent, this);
  183.  
  184.                 if (auto pGpu = GetGpuInterface())
  185.                 {
  186.                         gpu_pfx2::SFeatureParametersVelocityOmniDirectional params;
  187.                         params.velocity = m_velocity.GetBaseValue();
  188.                         pGpu->SetParameters(params);
  189.                 }
  190.         }
  191.  
  192.         virtual void Serialize(Serialization::IArchive& ar) override
  193.         {
  194.                 CParticleFeature::Serialize(ar);
  195.                 ar(m_velocity, "Velocity", "Velocity");
  196.         }
  197.  
  198.         virtual void InitParticles(const SUpdateContext& context) override
  199.         {
  200.                 CRY_PFX2_PROFILE_DETAIL;
  201.  
  202.                 CParticleContainer& container = context.m_container;
  203.                 IOVec3Stream velocities = container.GetIOVec3Stream(EPVF_Velocity);
  204.  
  205.                 STempModBuffer velocityMults(context, m_velocity);
  206.                 velocityMults.ModifyInit(context, m_velocity, container.GetSpawnedRange());
  207.  
  208.                 CRY_PFX2_FOR_SPAWNED_PARTICLES(context)
  209.                 {
  210.                         const Vec3 wVelocity0 = velocities.Load(particleId);
  211.                         const float velocity = velocityMults.m_stream.SafeLoad(particleId);
  212.                         const Vec3 oVelocity = context.m_spawnRng.RandSphere() * velocity;
  213.                         const Vec3 wVelocity1 = wVelocity0 + oVelocity;
  214.                         velocities.Store(particleId, wVelocity1);
  215.                 }
  216.                 CRY_PFX2_FOR_END;
  217.         }
  218.  
  219. private:
  220.         CParamMod<SModParticleSpawnInit, UFloat10> m_velocity;
  221. };
  222.  
  223. CRY_PFX2_IMPLEMENT_FEATURE(CParticleFeature, CFeatureVelocityOmniDirectional, "Velocity", "OmniDirectional", colorVelocity);
  224.  
  225. //////////////////////////////////////////////////////////////////////////
  226.  
  227. class CFeatureVelocityInherit : public CParticleFeature
  228. {
  229. public:
  230.         CRY_PFX2_DECLARE_FEATURE
  231.  
  232.         CFeatureVelocityInherit()
  233.                 : m_scale(1.0f)
  234.                 , CParticleFeature(gpu_pfx2::eGpuFeatureType_VelocityInherit) {}
  235.  
  236.         virtual void AddToComponent(CParticleComponent* pComponent, SComponentParams* pParams) override
  237.         {
  238.                 pComponent->AddToUpdateList(EUL_InitUpdate, this);
  239.                 m_scale.AddToComponent(pComponent, this);
  240.  
  241.                 if (auto gpuInt = GetGpuInterface())
  242.                 {
  243.                         gpu_pfx2::SFeatureParametersScale params;
  244.                         params.scale = m_scale.GetBaseValue();
  245.                         gpuInt->SetParameters(params);
  246.                 }
  247.         }
  248.  
  249.         virtual void Serialize(Serialization::IArchive& ar) override
  250.         {
  251.                 CParticleFeature::Serialize(ar);
  252.                 ar(m_scale, "Scale", "Scale");
  253.         }
  254.  
  255.         virtual void InitParticles(const SUpdateContext& context) override
  256.         {
  257.                 CRY_PFX2_PROFILE_DETAIL;
  258.  
  259.                 if (context.m_parentContainer.HasData(EPVF_AngularVelocity))
  260.                         InheritVelocity<true>(context);
  261.                 else
  262.                         InheritVelocity<false>(context);
  263.         }
  264.  
  265.         template<bool hasRotation>
  266.         void InheritVelocity(const SUpdateContext& context)
  267.         {
  268.                 CRY_PFX2_PROFILE_DETAIL;
  269.  
  270.                 CParticleContainer& parentContainer = context.m_parentContainer;
  271.                 CParticleContainer& container = context.m_container;
  272.                 IPidStream parentIds = container.GetIPidStream(EPDT_ParentId);
  273.                 const IVec3Stream positions = container.GetIVec3Stream(EPVF_Position);
  274.                 const IVec3Stream parentPositions = parentContainer.GetIVec3Stream(EPVF_Position);
  275.                 const IVec3Stream parentVelocities = parentContainer.GetIVec3Stream(EPVF_Velocity);
  276.                 const IVec3Stream parentAngularVelocities = parentContainer.GetIVec3Stream(EPVF_AngularVelocity);
  277.                 IOVec3Stream velocities = container.GetIOVec3Stream(EPVF_Velocity);
  278.  
  279.                 STempModBuffer scales(context, m_scale);
  280.                 scales.ModifyInit(context, m_scale, container.GetSpawnedRange());
  281.  
  282.                 CRY_PFX2_FOR_SPAWNED_PARTICLES(context)
  283.                 {
  284.                         const float scale = scales.m_stream.SafeLoad(particleId);
  285.                         const TParticleId parentId = parentIds.Load(particleId);
  286.                         const Vec3 wVelocity0 = velocities.Load(particleId);
  287.                         Vec3 wInheritVelocity = parentVelocities.Load(parentId);
  288.                         if (hasRotation)
  289.                         {
  290.                                 const Vec3 wPos = positions.Load(particleId);
  291.                                 const Vec3 wParentPos = parentPositions.Load(parentId);
  292.                                 const Vec3 wParentAngularVelocity = parentAngularVelocities.Load(parentId);
  293.                                 wInheritVelocity += wParentAngularVelocity ^ (wPos - wParentPos);
  294.                         }
  295.                         const Vec3 wVelocity1 = wVelocity0 + wInheritVelocity * scale;
  296.                         velocities.Store(particleId, wVelocity1);
  297.                 }
  298.                 CRY_PFX2_FOR_END;
  299.         }
  300.  
  301. private:
  302.         CParamMod<SModParticleSpawnInit, SFloat> m_scale;
  303. };
  304.  
  305. CRY_PFX2_IMPLEMENT_FEATURE(CParticleFeature, CFeatureVelocityInherit, "Velocity", "Inherit", colorVelocity);
  306.  
  307. //////////////////////////////////////////////////////////////////////////
  308.  
  309. class CFeatureVelocityCompass : public CParticleFeature
  310. {
  311. public:
  312.         CRY_PFX2_DECLARE_FEATURE
  313.  
  314.         CFeatureVelocityCompass()
  315.                 : m_azimuth(0.0f)
  316.                 , m_angle(0.0f)
  317.                 , m_velocity(0.0f) {}
  318.  
  319.         virtual void AddToComponent(CParticleComponent* pComponent, SComponentParams* pParams) override
  320.         {
  321.                 pComponent->AddToUpdateList(EUL_InitUpdate, this);
  322.                 m_azimuth.AddToComponent(pComponent, this);
  323.                 m_angle.AddToComponent(pComponent, this);
  324.                 m_velocity.AddToComponent(pComponent, this);
  325.         }
  326.  
  327.         virtual void Serialize(Serialization::IArchive& ar) override
  328.         {
  329.                 CParticleFeature::Serialize(ar);
  330.                 ar(m_azimuth, "Azimuth", "Azimuth");
  331.                 ar(m_angle, "Angle", "Angle");
  332.                 ar(m_velocity, "Velocity", "Velocity");
  333.         }
  334.  
  335.         virtual void InitParticles(const SUpdateContext& context) override
  336.         {
  337.                 CRY_PFX2_PROFILE_DETAIL;
  338.  
  339.                 const float halfPi = gf_PI * 0.5f;
  340.                 CParticleContainer& parentContainer = context.m_parentContainer;
  341.                 CParticleContainer& container = context.m_container;
  342.                 const Quat defaultQuat = context.m_runtime.GetEmitter()->GetLocation().q;
  343.                 IPidStream parentIds = container.GetIPidStream(EPDT_ParentId);
  344.                 IOVec3Stream velocities = container.GetIOVec3Stream(EPVF_Velocity);
  345.                 IQuatStream parentQuats = parentContainer.GetIQuatStream(EPQF_Orientation, defaultQuat);
  346.                 STempModBuffer azimuths(context, m_azimuth);
  347.                 STempModBuffer angles(context, m_angle);
  348.                 STempModBuffer velocityValues(context, m_velocity);
  349.                 azimuths.ModifyInit(context, m_azimuth, container.GetSpawnedRange());
  350.                 angles.ModifyInit(context, m_angle, container.GetSpawnedRange());
  351.                 velocityValues.ModifyInit(context, m_velocity, container.GetSpawnedRange());
  352.  
  353.                 CRY_PFX2_FOR_SPAWNED_PARTICLES(context)
  354.                 {
  355.                         const TParticleId parentId = parentIds.Load(particleId);
  356.                         const Quat wQuat = parentQuats.SafeLoad(parentId);
  357.                         const float azimuth = azimuths.m_stream.SafeLoad(particleId) + halfPi;
  358.                         const float altitude = angles.m_stream.SafeLoad(particleId) + halfPi;
  359.                         const float velocity = velocityValues.m_stream.SafeLoad(particleId);
  360.                         const Vec3 oVelocity = PolarCoordToVec3(azimuth, altitude) * velocity;
  361.                         const Vec3 wVelocity0 = velocities.Load(particleId);
  362.                         const Vec3 wVelocity1 = wVelocity0 + wQuat * oVelocity;
  363.                         velocities.Store(particleId, wVelocity1);
  364.                 }
  365.                 CRY_PFX2_FOR_END;
  366.         }
  367.  
  368. private:
  369.         CParamMod<SModParticleSpawnInit, SAngle360> m_azimuth;
  370.         CParamMod<SModParticleSpawnInit, UAngle180> m_angle;
  371.         CParamMod<SModParticleSpawnInit, SFloat10> m_velocity;
  372. };
  373.  
  374. CRY_PFX2_IMPLEMENT_FEATURE(CParticleFeature, CFeatureVelocityCompass, "Velocity", "Compass", colorVelocity);
  375.  
  376. }
  377.  
downloadFeatureVelocity.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