BVB Source Codes

CRYENGINE Show ParticleEffect.h Source code

Return Download CRYENGINE: download ParticleEffect.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   ParticleEffect.h
  5. //  Version:     v1.00
  6. //  Created:     10/7/2003 by Timur.
  7. //  Compilers:   Visual Studio.NET
  8. //  Description:
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13.  
  14. #ifndef __particleeffect_h__
  15. #define __particleeffect_h__
  16. #pragma once
  17.  
  18. #include <CryParticleSystem/IParticles.h>
  19. #include "Cry3DEngineBase.h"
  20. #include <CryParticleSystem/ParticleParams.h>
  21. #include "ParticleUtils.h"
  22. #include <CryCore/Containers/CryPtrArray.h>
  23. #include <CryParticleSystem/Options.h>
  24. #include <CrySystem/ICryMiniGUI.h>
  25.  
  26. #if CRY_PLATFORM_DESKTOP
  27.         #define PARTICLE_EDITOR_FUNCTIONS
  28. #endif
  29.  
  30. //////////////////////////////////////////////////////////////////////////
  31. // Set of flags that can have 3 states: forced on, forced off, or neutral.
  32. template<class T>
  33. struct TrinaryFlags
  34. {
  35.         T On, Off;
  36.  
  37.         TrinaryFlags()
  38.                 : On(0), Off(0) {}
  39.  
  40.         void Clear()
  41.         { On = Off = 0; }
  42.  
  43.         // Set from an int where -1 is off, 0 is neutral, 1 is forced
  44.         void SetState(int state, T flags)
  45.         {
  46.                 On &= ~flags;
  47.                 Off &= ~flags;
  48.                 if (state < 0)
  49.                         Off |= flags;
  50.                 else if (state > 0)
  51.                         On |= flags;
  52.         }
  53.  
  54.         TrinaryFlags& operator|=(T flags)
  55.         { On |= flags; return *this; }
  56.         TrinaryFlags& operator&=(T flags)
  57.         { Off |= ~flags; return *this; }
  58.  
  59.         T operator&(T flags) const
  60.         { return (flags | On) & ~Off; }
  61.  
  62.         T operator&(TrinaryFlags<T> const& other) const
  63.         { return (On | other.On) & ~(Off | other.Off); }
  64. };
  65.  
  66. //////////////////////////////////////////////////////////////////////////
  67. // Requirements and attributes of particle effects
  68. enum EEffectFlags
  69. {
  70.         EFF_LOADED = BIT(0),
  71.  
  72.         // Environmental requirements.
  73.         ENV_GRAVITY   = BIT(1),
  74.         ENV_WIND      = BIT(2),
  75.         ENV_WATER     = BIT(3),
  76.  
  77.         ENV_PHYS_AREA = ENV_GRAVITY | ENV_WIND | ENV_WATER,
  78.  
  79.         // Collision targets.
  80.         ENV_TERRAIN         = BIT(4),
  81.         ENV_STATIC_ENT      = BIT(5),
  82.         ENV_DYNAMIC_ENT     = BIT(6),
  83.         ENV_COLLIDE_INFO    = BIT(7),
  84.  
  85.         ENV_COLLIDE_ANY     = ENV_TERRAIN | ENV_STATIC_ENT | ENV_DYNAMIC_ENT,
  86.         ENV_COLLIDE_PHYSICS = ENV_STATIC_ENT | ENV_DYNAMIC_ENT,
  87.         ENV_COLLIDE_CACHE   = ENV_TERRAIN | ENV_STATIC_ENT,
  88.  
  89.         // Additional effects.
  90.         EFF_AUDIO = BIT(8),           // Ensures execution of audio relevant code.
  91.         EFF_FORCE = BIT(9),           // Produces physical force.
  92.  
  93.         EFF_ANY   = EFF_AUDIO | EFF_FORCE,
  94.  
  95.         // Exclusive rendering methods.
  96.         REN_SPRITE   = BIT(10),
  97.         REN_GEOMETRY = BIT(11),
  98.         REN_DECAL    = BIT(12),
  99.         REN_LIGHTS   = BIT(13),         // Adds light to scene.
  100.  
  101.         REN_ANY      = REN_SPRITE | REN_GEOMETRY | REN_DECAL | REN_LIGHTS,
  102.  
  103.         // Visual effects of particles
  104.         REN_CAST_SHADOWS = BIT(14),
  105.         REN_BIND_CAMERA  = BIT(15),
  106.         REN_SORT         = BIT(16),
  107.  
  108.         // General functionality
  109.         EFF_DYNAMIC_BOUNDS = BIT(17),   // Requires updating particles every frame.
  110. };
  111.  
  112. struct STileInfo
  113. {
  114.         Vec2  vSize;                      // Size of texture tile UVs.
  115.         float fTileCount, fTileStart;     // Range of tiles in texture for emitter.
  116. };
  117.  
  118. struct SPhysForces
  119. {
  120.         Vec3  vAccel;
  121.         Vec3  vWind;
  122.         Plane plWater;
  123.  
  124.         SPhysForces()
  125.         {}
  126.  
  127.         SPhysForces(type_zero)
  128.                 : vAccel(ZERO), vWind(ZERO), plWater(Vec3(0, 0, 1), -WATER_LEVEL_UNKNOWN)
  129.         {}
  130.  
  131.         void Add(SPhysForces const& other, uint32 nEnvFlags)
  132.         {
  133.                 if (nEnvFlags & ENV_GRAVITY)
  134.                         vAccel = other.vAccel;
  135.                 if (nEnvFlags & ENV_WIND)
  136.                         vWind += other.vWind;
  137.                 if (nEnvFlags & ENV_WATER)
  138.                         if (other.plWater.d < plWater.d)
  139.                                 plWater = other.plWater;
  140.         }
  141. };
  142.  
  143. inline bool HasWater(const Plane& pl)
  144. {
  145.         return pl.d < -WATER_LEVEL_UNKNOWN;
  146. }
  147.  
  148. // Helper structures for emitter functions
  149.  
  150. struct SForceParams : SPhysForces
  151. {
  152.         float fDrag;
  153.         float fStretch;
  154. };
  155.  
  156. // Options for computing static bounds
  157. struct FStaticBounds
  158. {
  159.         Vec3  vSpawnSize;
  160.         float fAngMax;
  161.         float fSpeedScale;
  162.         bool  bWithSize;
  163.         float fMaxLife;
  164.  
  165.         FStaticBounds()
  166.                 : vSpawnSize(0), fAngMax(0), fSpeedScale(1), bWithSize(true), fMaxLife(fHUGE) {}
  167. };
  168.  
  169. struct FEmitterRandom
  170. {
  171.         static type_min RMin() { return VMIN; }
  172.         static type_max RMax() { return VMAX; }
  173.         static type_min EMin() { return VMIN; }
  174.         static type_max EMax() { return VMAX; }
  175. };
  176.  
  177. struct FEmitterFixed
  178. {
  179.         CChaosKey ChaosKey;
  180.         float     fStrength;
  181.  
  182.         CChaosKey RMin() const { return ChaosKey; }
  183.         CChaosKey RMax() const { return ChaosKey; }
  184.         float     EMin() const { return fStrength; }
  185.         float     EMax() const { return fStrength; }
  186. };
  187.  
  188. struct SEmitParams;
  189.  
  190. //
  191. // Additional runtime parameters.
  192. //
  193. struct ResourceParticleParams
  194.         : ParticleParams, Cry3DEngineBase, ZeroInit<ResourceParticleParams>
  195. {
  196.         // Texture, material, geometry params.
  197.         float                 fTexAspect;               // H/V aspect ratio.
  198.         uint16                mConfigSpecMask;          // Allowed config specs.
  199.         _smart_ptr<IMaterial> pMaterial;                // Used to override the material
  200.         _smart_ptr<IStatObj>  pStatObj;                 // If it isn't set to 0, this object will be used instead of a sprite
  201.         uint32                nEnvFlags;                // Summary of environment info needed for effect.
  202.         TrinaryFlags<uint64>  nRenObjFlags;             // Flags for renderer, combining FOB_ and OS_.
  203.         SParticleShaderData   ShaderData;               // Data to be used by the particle shaders
  204.  
  205.         ResourceParticleParams()
  206.         {
  207.                 ComputeShaderData();
  208.                 ComputeEnvironmentFlags();
  209.         }
  210.  
  211.         explicit ResourceParticleParams(const ParticleParams& params)
  212.                 : ParticleParams(params)
  213.         {
  214.                 ComputeShaderData();
  215.                 ComputeEnvironmentFlags();
  216.         }
  217.  
  218.         bool ResourcesLoaded() const
  219.         {
  220.                 return nEnvFlags & EFF_LOADED;
  221.         }
  222.  
  223.         int   LoadResources(const char* pEffectName);
  224.         void  UnloadResources();
  225.         void  UpdateTextureAspect();
  226.  
  227.         void  ComputeShaderData();
  228.         void  ComputeEnvironmentFlags();
  229.         bool  IsActive() const;
  230.  
  231.         void  GetStaticBounds(AABB& bbResult, const QuatTS& loc, const SPhysForces& forces, const FStaticBounds& opts) const;
  232.  
  233.         float GetTravelBounds(AABB& bbResult, const QuatTS& loc, const SForceParams& forces, const FStaticBounds& opts, const FEmitterFixed& var) const;
  234.  
  235.         float GetMaxObjectSize() const
  236.         {
  237.                 return sqrt_fast_tpl(sqr(1.f + abs(fPivotX.GetMaxValue())) * sqr(fAspect.GetMaxValue()) + sqr(1.f + abs(fPivotY.GetMaxValue())));
  238.         }
  239.         float GetMaxObjectSize(IMeshObj* pObj) const
  240.         {
  241.                 if (pObj)
  242.                 {
  243.                         AABB bb = pObj->GetAABB();
  244.                         if (bNoOffset || ePhysicsType == ePhysicsType.RigidBody)
  245.                                 // Rendered at origin.
  246.                                 return sqrt_fast_tpl(max(bb.min.GetLengthSquared(), bb.max.GetLengthSquared()));
  247.                         else
  248.                                 // Rendered at center.
  249.                                 return bb.GetRadius();
  250.                 }
  251.                 else
  252.                 {
  253.                         return GetMaxObjectSize();
  254.                 }
  255.         }
  256.         bool IsGeometryCentered() const
  257.         {
  258.                 return !bNoOffset && ePhysicsType != ePhysicsType.RigidBody;
  259.         }
  260.         float GetMaxVisibleSize() const;
  261.  
  262.         void  GetMemoryUsage(ICrySizer* pSizer) const
  263.         {
  264.                 pSizer->AddObject(this, sizeof(*this));
  265.                 TypeInfo().GetMemoryUsage(pSizer, this);
  266.         }
  267.  
  268. protected:
  269.  
  270.         void GetMaxTravelBounds(AABB& bbResult, const QuatTS& loc, const SPhysForces& forces, const FStaticBounds& opts) const;
  271.  
  272.         template<class Var>
  273.         void GetEmitParams(SEmitParams& emit, const QuatTS& loc, const SPhysForces& forces, const FStaticBounds& opts, const Var& var) const;
  274. };
  275.  
  276. struct FMaxEffectLife
  277. {
  278.         OPT_STRUCT(FMaxEffectLife)
  279.         OPT_VAR(bool, bAllChildren)
  280.         OPT_VAR(bool, bIndirectChildren)
  281.         OPT_VAR(bool, bParticleLife)
  282.         OPT_VAR(float, fEmitterMaxLife)
  283. };
  284.  
  285. /*!     CParticleEffect implements IParticleEffect interface and contain all components necessary to
  286.     to create the effect
  287.  */
  288. class CParticleEffect : public IParticleEffect, public Cry3DEngineBase, public stl::intrusive_linked_list_node<CParticleEffect>
  289. {
  290. public:
  291.         CParticleEffect();
  292.         CParticleEffect(const CParticleEffect& in, bool bResetInheritance = false);
  293.         CParticleEffect(const char* sName);
  294.         CParticleEffect(const ParticleParams& params);
  295.         ~CParticleEffect();
  296.  
  297.         void Release()
  298.         {
  299.                 --m_nRefCounter;
  300.                 if (m_nRefCounter <= 0)
  301.                         delete this;
  302.         }
  303.  
  304.         // IParticle interface.
  305.         virtual int               GetVersion() const
  306.         { return 1; }
  307.         virtual IParticleEmitter* Spawn(const ParticleLoc& loc, const SpawnParams* pSpawnParams = NULL);
  308.  
  309.         virtual void              SetName(const char* sFullName);
  310.         virtual const char*       GetName() const
  311.         { return m_strName.c_str(); }
  312.         virtual stack_string      GetFullName() const;
  313.  
  314.         virtual void              SetEnabled(bool bEnabled);
  315.         virtual bool              IsEnabled() const
  316.         { return m_pParticleParams && m_pParticleParams->bEnabled; };
  317.         virtual bool              IsTemporary() const;
  318.  
  319.         //////////////////////////////////////////////////////////////////////////
  320.         //! Load resources, required by this particle effect (Textures and geometry).
  321.         virtual bool LoadResources()
  322.         { return LoadResources(true); }
  323.         virtual void UnloadResources()
  324.         { UnloadResources(true); }
  325.  
  326.         //////////////////////////////////////////////////////////////////////////
  327.         // Child particle systems.
  328.         //////////////////////////////////////////////////////////////////////////
  329.         int              GetChildCount() const
  330.         { return m_children.size(); }
  331.         IParticleEffect* GetChild(int index) const
  332.         { return &m_children[index]; }
  333.  
  334.         virtual void             ClearChilds();
  335.         virtual void             InsertChild(int slot, IParticleEffect* pEffect);
  336.         virtual int              FindChild(IParticleEffect* pEffect) const;
  337.  
  338.         virtual void             SetParent(IParticleEffect* pParent);
  339.         virtual IParticleEffect* GetParent() const
  340.         { return m_parent; }
  341.  
  342.         //////////////////////////////////////////////////////////////////////////
  343.         virtual void                  SetParticleParams(const ParticleParams& params);
  344.         virtual const ParticleParams& GetParticleParams() const;
  345.         virtual const ParticleParams& GetDefaultParams() const;
  346.  
  347.         virtual void                  Serialize(XmlNodeRef node, bool bLoading, bool bAll);
  348.         virtual void                  Serialize(Serialization::IArchive& ar);
  349.         virtual void                  Reload(bool bAll);
  350.  
  351.         virtual IParticleAttributes& GetAttributes();
  352.  
  353.         void                         GetMemoryUsage(ICrySizer* pSizer) const;
  354.  
  355.         // Further interface.
  356.  
  357.         const ResourceParticleParams& GetParams() const
  358.         {
  359.                 assert(m_pParticleParams);
  360.                 return *m_pParticleParams;
  361.         }
  362.  
  363.         void                  InstantiateParams();
  364.         const ParticleParams& GetDefaultParams(ParticleParams::EInheritance eInheritance, int nVersion) const;
  365.         void                  PropagateParticleParams(const ParticleParams& params);
  366.  
  367.         const char*           GetBaseName() const;
  368.  
  369.         bool                  IsNull() const
  370.         {
  371.                 // Empty placeholder effect.
  372.                 return !m_pParticleParams && m_children.empty();
  373.         }
  374.         bool                   ResourcesLoaded(bool bAll) const;
  375.         bool                   LoadResources(bool bAll, cstr sSource = 0) const;
  376.         void                   UnloadResources(bool bAll) const;
  377.         bool                   IsActive(bool bAll = false) const;
  378.         uint32                 GetEnvironFlags(bool bAll) const;
  379.  
  380.         CParticleEffect*       FindChild(const char* szChildName) const;
  381.         const CParticleEffect* FindActiveEffect(int nVersion) const;
  382.  
  383.         CParticleEffect*       GetIndirectParent() const;
  384.  
  385.         float                  Get(FMaxEffectLife const& opts) const;
  386.         float                  GetMaxParticleFullLife() const
  387.         {
  388.                 return Get(FMaxEffectLife().bParticleLife(1).bIndirectChildren(1));
  389.         }
  390.         float GetMaxParticleSize(bool bParent = false) const;
  391.         float GetEquilibriumAge(bool bAll) const;
  392.  
  393.         void  GetEffectCounts(SEffectCounts& counts) const;
  394.  
  395. private:
  396.  
  397.         //////////////////////////////////////////////////////////////////////////
  398.         // Name of effect or sub-effect, minimally qualified.
  399.         // For top-level effects, this includes library.group.
  400.         // For all child effects, is just the base name.
  401.         string                  m_strName;
  402.         ResourceParticleParams* m_pParticleParams;
  403.  
  404.         //! Parenting.
  405.         CParticleEffect*               m_parent;
  406.         SmartPtrArray<CParticleEffect> m_children;
  407. };
  408.  
  409. //
  410. // Travel utilities
  411. //
  412. namespace Travel
  413. {
  414. #define fDRAG_APPROX_THRESHOLD 0.01f              // Max inaccuracy we allow in fast drag force approximation
  415.  
  416. inline float TravelDistance(float fV, float fDrag, float fT)
  417. {
  418.         float fDecay = fDrag * fT;
  419.         if (fDecay < fDRAG_APPROX_THRESHOLD)
  420.                 return fV * fT * (1.f - fDecay);
  421.         else
  422.                 // Compute accurate distance with drag.
  423.                 return fV / fDrag * (1.f - expf(-fDecay));
  424. }
  425.  
  426. inline float TravelSpeed(float fV, float fDrag, float fT)
  427. {
  428.         float fDecay = fDrag * fT;
  429.         if (fDecay < fDRAG_APPROX_THRESHOLD)
  430.                 // Fast approx drag computation.
  431.                 return fV * (1.f - fDecay);
  432.         else
  433.                 return fV * expf(-fDecay);
  434. }
  435.  
  436. inline void Travel(Vec3& vPos, Vec3& vVel, float fTime, const SForceParams& forces)
  437. {
  438.         // Analytically compute new velocity and position, accurate for any time step.
  439.         if (forces.fDrag * fTime >= fDRAG_APPROX_THRESHOLD)
  440.         {
  441.                 //
  442.                 // Air resistance proportional to velocity is typical for slower laminar movement.
  443.                 // For drag d (units in 1/time), wind W, and gravity G:
  444.                 //
  445.                 //              V' = d (W-V) + G
  446.                 //
  447.                 //      The analytic solution is:
  448.                 //
  449.                 //              VT = G/d + W,                                                                   terminal velocity
  450.                 //              V = (V-VT) e^(-d t) + VT
  451.                 //              X = (V-VT) (1 - e^(-d t))/d + VT t
  452.                 //
  453.                 //      A faster approximation, accurate to 2nd-order t is:
  454.                 //
  455.                 //              e^(-d t) => 1 - d t + d^2 t^2/2
  456.                 //              X += V t + (G + (W-V) d) t^2/2
  457.                 //              V += (G + (W-V) d) t
  458.                 //
  459.  
  460.                 float fInvDrag = 1.f / forces.fDrag;
  461.                 Vec3 vTerm = forces.vWind + forces.vAccel * fInvDrag;
  462.                 float fDecay = 1.f - expf(-forces.fDrag * fTime);
  463.                 float fT = fDecay * fInvDrag;
  464.                 vPos += vVel * fT + vTerm * (fTime - fT);
  465.                 vVel = Lerp(vVel, vTerm, fDecay);
  466.         }
  467.         else
  468.         {
  469.                 // Fast approx drag computation.
  470.                 Vec3 vAccel = forces.vAccel + (forces.vWind - vVel) * forces.fDrag;
  471.                 vPos += vVel * fTime + vAccel * (fTime * fTime * 0.5f);
  472.                 vVel += vAccel * fTime;
  473.         }
  474. }
  475.  
  476. float TravelDistanceApprox(const Vec3& vVel, float fTime, const SForceParams& forces);
  477.  
  478. float TravelVolume(const AABB& bbSource, const AABB& bbTravel, float fDist, float fSize);
  479. };
  480.  
  481. //
  482. // Other utilities
  483. //
  484.  
  485. IStatObj::SSubObject* GetSubGeometry(IStatObj* pParent, int i);
  486. int                   GetSubGeometryCount(IStatObj* pParent);
  487.  
  488. #endif //__particleeffect_h__
  489.  
downloadParticleEffect.h 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