BVB Source Codes

CRYENGINE Show FeatureAngles.cpp Source code

Return Download CRYENGINE: download FeatureAngles.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 <CrySerialization/Math.h>
  5. #include "ParticleSystem/ParticleFeature.h"
  6. #include "ParamTraits.h"
  7. #include "FeatureAngles.h"
  8.  
  9. CRY_PFX2_DBG
  10.  
  11. namespace pfx2
  12. {
  13.  
  14. EParticleDataType PDT(EPDT_Angle2D, float);
  15. EParticleDataType PDT(EPDT_Spin2D, float);
  16.  
  17. //////////////////////////////////////////////////////////////////////////
  18. // CFeatureAnglesRotate2D
  19.  
  20. class CFeatureAnglesRotate2D : public CParticleFeature
  21. {
  22. public:
  23.         CRY_PFX2_DECLARE_FEATURE
  24.  
  25.         CFeatureAnglesRotate2D()
  26.                 : m_initialAngle(0.0f)
  27.                 , m_randomAngle(0.0f)
  28.                 , m_initialSpin(0.0f)
  29.                 , m_randomSpin(0.0f) {}
  30.  
  31.         virtual void AddToComponent(CParticleComponent* pComponent, SComponentParams* pParams) override
  32.         {
  33.                 pComponent->AddToUpdateList(EUL_InitUpdate, this);
  34.                 pComponent->AddParticleData(EPDT_Angle2D);
  35.  
  36.                 if (!IsDefault(m_initialSpin, 0.0f) || !IsDefault(m_randomSpin, 0.0f))
  37.                         pComponent->AddParticleData(EPDT_Spin2D);
  38.         }
  39.  
  40.         virtual void Serialize(Serialization::IArchive& ar) override
  41.         {
  42.                 CParticleFeature::Serialize(ar);
  43.                 ar(m_initialAngle, "InitialAngle", "Initial Angle");
  44.                 ar(m_randomAngle, "RandomAngle", "Random Angle");
  45.                 ar(m_initialSpin, "InitialSpin", "Initial Spin");
  46.                 ar(m_randomSpin, "RandomSpin", "Random Spin");
  47.  
  48.                 if (ar.isInput() && GetVersion(ar) < 8)
  49.                 {
  50.                         m_initialAngle = -m_initialAngle;
  51.                         m_initialSpin = -m_initialSpin;
  52.                 }
  53.         }
  54.  
  55.         virtual void InitParticles(const SUpdateContext& context) override
  56.         {
  57.                 CRY_PFX2_PROFILE_DETAIL;
  58.  
  59.                 CParticleContainer& container = context.m_container;
  60.  
  61.                 IOFStream angles = container.GetIOFStream(EPDT_Angle2D);
  62.                 const floatv initAngle = ToFloatv(m_initialAngle.Get());
  63.                 const floatv randAngle = ToFloatv(m_randomAngle.Get());
  64.                 CRY_PFX2_FOR_SPAWNED_PARTICLEGROUP(context)
  65.                 {
  66.                         const floatv snorm = context.m_spawnRngv.RandSNorm();
  67.                         const floatv angle = MAdd(randAngle, snorm, initAngle);
  68.                         angles.Store(particleGroupId, angle);
  69.                 }
  70.                 CRY_PFX2_FOR_END;
  71.  
  72.                 if (container.HasData(EPDT_Spin2D))
  73.                 {
  74.                         IOFStream spins = container.GetIOFStream(EPDT_Spin2D);
  75.                         const floatv initSpin = ToFloatv(m_initialSpin.Get());
  76.                         const floatv randSpin = ToFloatv(m_randomSpin.Get());
  77.                         CRY_PFX2_FOR_SPAWNED_PARTICLEGROUP(context)
  78.                         {
  79.                                 const floatv snorm = context.m_spawnRngv.RandSNorm();
  80.                                 const floatv spin = MAdd(randSpin, snorm, initSpin);
  81.                                 spins.Store(particleGroupId, spin);
  82.                         }
  83.                         CRY_PFX2_FOR_END;
  84.                 }
  85.         }
  86.  
  87. private:
  88.         SAngle360 m_initialAngle;
  89.         UAngle180 m_randomAngle;
  90.         SAngle    m_initialSpin;
  91.         UAngle    m_randomSpin;
  92. };
  93.  
  94. CRY_PFX2_IMPLEMENT_FEATURE(CParticleFeature, CFeatureAnglesRotate2D, "Angles", "Rotate2D", colorAngles);
  95.  
  96. //////////////////////////////////////////////////////////////////////////
  97. // CFeatureAnglesRotate2D
  98.  
  99. class CFeatureAnglesRotate3D : public CParticleFeature
  100. {
  101. public:
  102.         CRY_PFX2_DECLARE_FEATURE
  103.  
  104.         CFeatureAnglesRotate3D()
  105.                 : m_initAngles(ZERO)
  106.                 , m_randomAngles(ZERO)
  107.                 , m_initialSpin(ZERO)
  108.                 , m_randomSpin(ZERO) {}
  109.  
  110.         virtual void AddToComponent(CParticleComponent* pComponent, SComponentParams* pParams) override
  111.         {
  112.                 pComponent->AddToUpdateList(EUL_InitUpdate, this);
  113.                 pComponent->AddParticleData(EPQF_Orientation);
  114.  
  115.                 if (m_initialSpin != Vec3(ZERO) || m_randomSpin != Vec3(ZERO))
  116.                         pComponent->AddParticleData(EPVF_AngularVelocity);
  117.         }
  118.  
  119.         virtual void Serialize(Serialization::IArchive& ar) override
  120.         {
  121.                 CParticleFeature::Serialize(ar);
  122.                 ar(m_initAngles, "InitialAngle", "Initial Angle");
  123.                 ar(m_randomAngles, "RandomAngle", "Random Angle");
  124.                 ar(m_initialSpin, "InitialSpin", "Initial Spin");
  125.                 ar(m_randomSpin, "RandomSpin", "Random Spin");
  126.         }
  127.  
  128.         virtual void InitParticles(const SUpdateContext& context) override
  129.         {
  130.                 CRY_PFX2_PROFILE_DETAIL;
  131.  
  132.                 CParticleContainer& container = context.m_container;
  133.                 IOQuatStream orientations = container.GetIOQuatStream(EPQF_Orientation);
  134.                 const Ang3 initAngles = FromVec3(m_initAngles);
  135.                 const Ang3 randomInitAngles = FromVec3(m_randomAngles);
  136.  
  137.                 CRY_PFX2_FOR_SPAWNED_PARTICLES(context)
  138.                 {
  139.                         const Quat wOrientation0 = orientations.Load(particleId);
  140.                         const Ang3 randAngle = RandomAng3(context.m_spawnRng, randomInitAngles);
  141.                         const Ang3 angle = initAngles + randAngle;
  142.                         const Quat oOrientation = Quat::CreateRotationXYZ(angle);
  143.                         const Quat wOrientation1 = wOrientation0 * oOrientation;
  144.                         orientations.Store(particleId, wOrientation1);
  145.                 }
  146.                 CRY_PFX2_FOR_END;
  147.  
  148.                 if (container.HasData(EPVF_AngularVelocity))
  149.                 {
  150.                         IOVec3Stream angularVelocities = container.GetIOVec3Stream(EPVF_AngularVelocity);
  151.                         const Ang3 initSpin = FromVec3(m_initialSpin);
  152.                         const Ang3 randSpin = FromVec3(m_randomSpin);
  153.                         CRY_PFX2_FOR_SPAWNED_PARTICLES(context)
  154.                         {
  155.                                 const Ang3 angularVelocity = RandomAng3(context.m_spawnRng, randSpin) + initSpin;
  156.                                 angularVelocities.Store(particleId, Vec3(angularVelocity));
  157.                         }
  158.                         CRY_PFX2_FOR_END;
  159.                 }
  160.         }
  161.  
  162. private:
  163.         ILINE Ang3 FromVec3(Vec3 v)
  164.         {
  165.                 return Ang3(DEG2RAD(-v.x), DEG2RAD(-v.y), DEG2RAD(v.z));
  166.         }
  167.  
  168.         ILINE Ang3 RandomAng3(SChaosKey& chaosKey, Ang3 mult)
  169.         {
  170.                 return Ang3(
  171.                   chaosKey.RandSNorm() * mult.x,
  172.                   chaosKey.RandSNorm() * mult.y,
  173.                   chaosKey.RandSNorm() * mult.z);
  174.         }
  175.  
  176.         Vec3 m_initAngles;
  177.         Vec3 m_randomAngles;
  178.         Vec3 m_initialSpin;
  179.         Vec3 m_randomSpin;
  180. };
  181.  
  182. CRY_PFX2_IMPLEMENT_FEATURE(CParticleFeature, CFeatureAnglesRotate3D, "Angles", "Rotate3D", colorAngles);
  183.  
  184. //////////////////////////////////////////////////////////////////////////
  185. // CFeatureAnglesProject
  186.  
  187. class CFeatureAnglesAlign : public CParticleFeature
  188. {
  189. private:
  190.         struct CTypeScreen
  191.         {
  192.                 CTypeScreen(const Matrix34& viewTM)
  193.                         : m_forward(-viewTM.GetColumn1()) {}
  194.                 ILINE Vec3 Sample(TParticleId particleId) const
  195.                 {
  196.                         return m_forward;
  197.                 }
  198.                 ILINE bool CanAlign(TParticleId particleId) const { return true; }
  199.                 const Vec3 m_forward;
  200.         };
  201.  
  202.         struct CTypeCamera
  203.         {
  204.                 CTypeCamera(const CParticleContainer& container, Vec3 cameraPos)
  205.                         : m_positions(container.GetIVec3Stream(EPVF_Position))
  206.                         , m_cameraPos(cameraPos) {}
  207.                 ILINE Vec3 Sample(TParticleId particleId) const
  208.                 {
  209.                         const Vec3 position = m_positions.Load(particleId);
  210.                         const Vec3 alignAxis = (m_cameraPos - position).GetNormalized();
  211.                         return alignAxis;
  212.                 }
  213.                 ILINE bool CanAlign(TParticleId particleId) const { return true; }
  214.                 const IVec3Stream m_positions;
  215.                 const Vec3 m_cameraPos;
  216.         };
  217.  
  218.         struct CTypeVelocity
  219.         {
  220.                 CTypeVelocity(const CParticleContainer& container)
  221.                         : m_velocity(container.GetIVec3Stream(EPVF_Velocity)) {}
  222.                 ILINE Vec3 Sample(TParticleId particleId) const
  223.                 {
  224.                         return m_velocity.Load(particleId).GetNormalized();
  225.                 }
  226.                 ILINE bool CanAlign(TParticleId particleId) const
  227.                 {
  228.                         return m_velocity.Load(particleId).GetLengthSquared() > FLT_EPSILON;
  229.                 }
  230.                 const IVec3Stream m_velocity;
  231.         };
  232.  
  233.         struct CTypeParent
  234.         {
  235.                 CTypeParent(const CParticleContainer& container, const CParticleContainer& parentContainer, Vec3 axis)
  236.                         : m_parentIds(container.GetIPidStream(EPDT_ParentId))
  237.                         , m_parentOrientations(parentContainer.GetIQuatStream(EPQF_Orientation))
  238.                         , m_axis(axis.GetNormalizedSafe()) {}
  239.                 ILINE Vec3 Sample(TParticleId particleId) const
  240.                 {
  241.                         const TParticleId parentId = m_parentIds.Load(particleId);
  242.                         const Quat parentOrientation = m_parentOrientations.Load(parentId);
  243.                         return parentOrientation * m_axis;
  244.                 }
  245.                 ILINE bool CanAlign(TParticleId particleId) const
  246.                 {
  247.                         const TParticleId parentId = m_parentIds.Load(particleId);
  248.                         return parentId != gInvalidId;
  249.                 }
  250.                 const IPidStream m_parentIds;
  251.                 const IQuatStream m_parentOrientations;
  252.                 const Vec3 m_axis;
  253.         };
  254.  
  255. public:
  256.         CRY_PFX2_DECLARE_FEATURE
  257.  
  258.         CFeatureAnglesAlign()
  259.                 : m_alignParticleAxis(EAlignParticleAxis::Normal)
  260.                 , m_alignType(EAlignType::Screen)
  261.                 , m_alignView(EAlignView::None)
  262.                 , m_axis(0.0f, 0.0f, 1.0f) {}
  263.        
  264.         virtual void AddToComponent(CParticleComponent* pComponent, SComponentParams* pParams) override
  265.         {
  266.                 pComponent->AddToUpdateList(EUL_Update, this);
  267.                 pComponent->AddParticleData(EPQF_Orientation);
  268.         }
  269.  
  270.         virtual void Serialize(Serialization::IArchive& ar) override
  271.         {
  272.                 CParticleFeature::Serialize(ar);
  273.                 ar(m_alignParticleAxis, "ParticleAxis", "Particle Axis");
  274.                 ar(m_alignType, "Type", "Align Type");
  275.                 if (m_alignType == EAlignType::Parent)
  276.                         ar(m_axis, "Axis", "Axis");
  277.                 if (m_alignType == EAlignType::Parent || m_alignType == EAlignType::Velocity)
  278.                         ar(m_alignView, "AlignView", "Align View");
  279.                 else
  280.                         m_alignView = EAlignView::None;
  281.         }
  282.  
  283.         virtual void Update(const SUpdateContext& context) override
  284.         {
  285.                 CRY_PFX2_PROFILE_DETAIL;
  286.  
  287.                 const CParticleContainer& container = context.m_container;
  288.                 const CParticleContainer& parentContainer = context.m_parentContainer;
  289.                 const Matrix34 viewTM = gEnv->p3DEngine->GetRenderingCamera().GetMatrix();
  290.                 const Vec3 cameraPos = gEnv->p3DEngine->GetRenderingCamera().GetPosition();
  291.  
  292.                 switch (m_alignType)
  293.                 {
  294.                 case EAlignType::Screen:
  295.                         AlignUpdate<CTypeScreen>(context, CTypeScreen(viewTM));
  296.                         break;
  297.                 case EAlignType::Camera:
  298.                         AlignUpdate<CTypeCamera>(context, CTypeCamera(container, cameraPos));
  299.                         break;
  300.                 case EAlignType::Velocity:
  301.                         AlignUpdate<CTypeVelocity>(context, CTypeVelocity(container));
  302.                         break;
  303.                 case EAlignType::Parent:
  304.                         AlignUpdate<CTypeParent>(context, CTypeParent(container, parentContainer, m_axis));
  305.                         break;
  306.                 }
  307.         }
  308.  
  309. private:
  310.         template<typename TTypeSampler>
  311.         void AlignUpdate(const SUpdateContext& context, const TTypeSampler& typeSampler)
  312.         {
  313.                 const Matrix34 viewTM = gEnv->p3DEngine->GetRenderingCamera().GetMatrix();
  314.                 const Vec3 cameraPos = gEnv->p3DEngine->GetRenderingCamera().GetPosition();
  315.                 const Vec3 forward = -viewTM.GetColumn1();
  316.  
  317.                 CParticleContainer& container = context.m_container;
  318.                 const IVec3Stream positions = container.GetIVec3Stream(EPVF_Position);
  319.                 IOQuatStream orientations = container.GetIOQuatStream(EPQF_Orientation);
  320.  
  321.                 CRY_PFX2_FOR_ACTIVE_PARTICLES(context)
  322.                 {
  323.                         if (!typeSampler.CanAlign(particleId))
  324.                                 continue;
  325.  
  326.                         const Quat orientation0 = orientations.Load(particleId);
  327.  
  328.                         const Vec3 particleAxis = GetParticleAxis(m_alignParticleAxis, orientation0);
  329.                         const Vec3 alignVec = typeSampler.Sample(particleId);
  330.                         const Quat fieldAlign = Quat::CreateRotationV0V1(particleAxis, alignVec);
  331.                         const Quat orientation1 = fieldAlign * orientation0;
  332.  
  333.                         if (m_alignView != EAlignView::None)
  334.                         {
  335.                                 const Vec3 position = positions.Load(particleId);
  336.                                 const Vec3 toCamera = m_alignView == EAlignView::Camera ? (cameraPos - position).GetNormalized() : forward;
  337.                                 const Vec3 particleOtherAxis = GetParticleOtherAxis(m_alignParticleAxis, orientation1);
  338.                                 const Vec3 cameraAlignAxis = alignVec.Cross(toCamera).GetNormalizedSafe();
  339.                                 const Quat cameraAlign = Quat::CreateRotationV0V1(particleOtherAxis, cameraAlignAxis);
  340.                                 const Quat orientation2 = cameraAlign * orientation1;
  341.                                 orientations.Store(particleId, orientation2);
  342.                         }
  343.                         else
  344.                         {
  345.                                 orientations.Store(particleId, orientation1);
  346.                         }
  347.                 }
  348.                 CRY_PFX2_FOR_END;
  349.         }
  350.  
  351. private:
  352.         EAlignParticleAxis m_alignParticleAxis;
  353.         EAlignType         m_alignType;
  354.         EAlignView         m_alignView;
  355.         Vec3               m_axis;
  356. };
  357.  
  358. CRY_PFX2_IMPLEMENT_FEATURE(CParticleFeature, CFeatureAnglesAlign, "Angles", "Align", colorAngles);
  359.  
  360. }
  361.  
downloadFeatureAngles.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