BVB Source Codes

CRYENGINE Show ParticleContainer.h Source code

Return Download CRYENGINE: download ParticleContainer.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:   ParticleContainer.h
  5. //  Version:     v1.00
  6. //  Created:     11/03/2010 by Corey (split out from other files).
  7. //  Compilers:   Visual Studio.NET
  8. //  Description:
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13.  
  14. #ifndef __particlecontainer_h__
  15. #define __particlecontainer_h__
  16. #pragma once
  17.  
  18. #include "ParticleEffect.h"
  19. #include "ParticleEnviron.h"
  20. #include "ParticleUtils.h"
  21. #include "ParticleList.h"
  22. #include "Particle.h"
  23. #include <CryRenderer/RenderElements/CREParticle.h>
  24.  
  25. class CParticleEmitter;
  26. class CParticleSubEmitter;
  27. struct SParticleVertexContext;
  28. struct SContainerCounts;
  29.  
  30. typedef ParticleList<CParticle>::Node TParticleElem;
  31.  
  32. //////////////////////////////////////////////////////////////////////////
  33. struct CRY_ALIGN(16) SParticleUpdateContext
  34. {
  35.         float fUpdateTime;
  36.         uint32 nEnvFlags;
  37.         Vec3 vEmitBox;
  38.         Vec3 vEmitScale;
  39.         AABB* pbbDynamicBounds;
  40.         bool bHasTarget;
  41.  
  42.         // Iteration support.
  43.         float fMaxLinearDeviation;
  44.         float fMaxLinearStepTime;
  45.         float fMinStepTime;
  46.  
  47.         // Sorting support.
  48.         Vec3 vMainCamPos;
  49.         float fCenterCamDist;
  50.         int nSortQuality;
  51.         bool b3DRotation;
  52.  
  53.         // Updated per emitter.
  54.         float fDensityAdjust;
  55.  
  56.         struct SSortElem
  57.         {
  58.                 const CParticle* pPart;
  59.                 float            fDist;
  60.  
  61.                 bool operator<(const SSortElem& r) const
  62.                 { return fDist < r.fDist; }
  63.         };
  64.         Array<SSortElem> aParticleSort;
  65.  
  66.         struct SSpaceLoop
  67.         {
  68.                 Vec3 vCenter, vSize;
  69.                 Vec3 vScaledAxes[3];
  70.         };
  71.         SSpaceLoop SpaceLoop;
  72. };
  73.  
  74. //////////////////////////////////////////////////////////////////////////
  75. // Particle rendering helper params.
  76. struct CRY_ALIGN(16) SPartRenderParams
  77. {
  78.         float m_fCamDistance;
  79.         float m_fMainBoundsScale;
  80.         float m_fMaxAngularDensity;
  81.         uint32 m_nRenFlags;
  82.         TrinaryFlags<uint64> m_nRenObjFlags;
  83.         uint16 m_nFogVolumeContribIdx;
  84.         float m_fHDRDynamicMultiplier;
  85.         uint16 m_nDeferredLightVolumeId;
  86. };
  87.  
  88. //////////////////////////////////////////////////////////////////////////
  89. // Contains, updates, and renders a list of particles, of a single effect
  90.  
  91. class CParticleContainer : public IParticleVertexCreator, public Cry3DEngineBase
  92. {
  93. public:
  94.  
  95.         CParticleContainer(CParticleContainer* pParent, CParticleEmitter* pMain, CParticleEffect const* pEffect);
  96.         ~CParticleContainer();
  97.  
  98.         // Associated structures.
  99.         ILINE const CParticleEffect*        GetEffect() const { return m_pEffect; }
  100.         ILINE CParticleEmitter&             GetMain()         { return *m_pMainEmitter; }
  101.         ILINE const CParticleEmitter&       GetMain() const   { return *m_pMainEmitter; }
  102.  
  103.         ILINE ResourceParticleParams const& GetParams() const
  104.         {
  105.                 return *m_pParams;
  106.         }
  107.  
  108.         float      GetAge() const;
  109.  
  110.         ILINE bool IsIndirect() const
  111.         {
  112.                 return m_pParentContainer != 0;
  113.         }
  114.         ILINE CParticleSubEmitter* GetDirectEmitter()
  115.         {
  116.                 if (!m_pParentContainer && !m_Emitters.empty())
  117.                 {
  118.                         assert(m_Emitters.size() == 1);
  119.                         return &m_Emitters.front();
  120.                 }
  121.                 return NULL;
  122.         }
  123.  
  124.         // If indirect container.
  125.         ILINE CParticleContainer* GetParent() const
  126.         {
  127.                 return m_pParentContainer;
  128.         }
  129.  
  130.         void                 Reset();
  131.  
  132.         CParticleSubEmitter* AddEmitter(CParticleSource* pSource);
  133.         CParticle*           AddParticle(SParticleUpdateContext& context, const CParticle& part);
  134.         void                 UpdateParticles();
  135.         void                 SyncUpdateParticles();
  136.         void                 UpdateEmitters(SParticleUpdateContext* pEmitContext = NULL);
  137.  
  138.         void                 EmitParticle(const EmitParticleData* pData);
  139.  
  140.         uint16               GetNextEmitterSequence()
  141.         {
  142.                 return m_nEmitterSequence++;
  143.         }
  144.         void  UpdateEffects();
  145.         float InvalidateStaticBounds();
  146.         void  Render(SRendParams const& RenParams, SPartRenderParams const& PRParams, const SRenderingPassInfo& passInfo);
  147.         void  RenderGeometry(const SRendParams& RenParams, const SRenderingPassInfo& passInfo);
  148.         void  RenderDecals(const SRenderingPassInfo& passInfo);
  149.         void  RenderLights(const SRendParams& RenParams, const SRenderingPassInfo& passInfo);
  150.  
  151.         // Bounds functions.
  152.         void   UpdateState();
  153.         void   SetDynamicBounds();
  154.  
  155.         uint32 NeedsDynamicBounds() const
  156.         {
  157. #ifndef _RELEASE
  158.                 if (GetCVars()->e_ParticlesDebug & AlphaBit('d'))
  159.                         // Force all dynamic bounds computation and culling.
  160.                         return EFF_DYNAMIC_BOUNDS;
  161. #endif
  162.                 return (m_nEnvFlags | m_nChildFlags) & EFF_DYNAMIC_BOUNDS;
  163.         }
  164.         bool StaticBoundsStable() const
  165.         {
  166.                 return GetAge() >= m_fAgeStaticBoundsStable;
  167.         }
  168.         AABB const& GetBounds() const
  169.         {
  170.                 return m_bbWorld;
  171.         }
  172.         AABB const& GetStaticBounds() const
  173.         {
  174.                 return m_bbWorldStat;
  175.         }
  176.         AABB const& GetDynamicBounds() const
  177.         {
  178.                 return m_bbWorldDyn;
  179.         }
  180.  
  181.         uint32 GetEnvironmentFlags() const;
  182.  
  183.         size_t GetNumParticles() const
  184.         {
  185.                 return m_Particles.size();
  186.         }
  187.  
  188.         uint32 GetChildFlags() const
  189.         {
  190.                 return m_nChildFlags;
  191.         }
  192.  
  193.         float GetContainerLife() const
  194.         {
  195.                 return m_fContainerLife;
  196.         }
  197.         void  UpdateContainerLife(float fAgeAdjust = 0.f);
  198.  
  199.         bool  GetTarget(ParticleTarget& target, const CParticleSubEmitter* pSubEmitter) const;
  200.  
  201.         float GetTimeToUpdate() const
  202.         {
  203.                 return GetAge() - m_fAgeLastUpdate;
  204.         }
  205.  
  206.         // Temp functions to update edited effects.
  207.         inline bool IsUsed() const
  208.         {
  209.                 return !m_bUnused;
  210.         }
  211.  
  212.         void SetUsed(bool b)
  213.         {
  214.                 m_bUnused = !b;
  215.         }
  216.  
  217.         int GetHistorySteps() const
  218.         {
  219.                 return m_nHistorySteps;
  220.         }
  221.         uint32 NeedsCollisionInfo() const
  222.         {
  223.                 return GetEnvironmentFlags() & ENV_COLLIDE_INFO;
  224.         }
  225.         float GetMaxParticleFullLife() const
  226.         {
  227.                 return m_fMaxParticleFullLife;
  228.         }
  229.  
  230.         void OnEffectChange();
  231.  
  232.         void ComputeUpdateContext(SParticleUpdateContext& context, float fUpdateTime);
  233.  
  234.         // Stat/profile functions.
  235.         SContainerCounts& GetCounts()
  236.         {
  237.                 return m_Counts;
  238.         }
  239.  
  240.         void GetCounts(SParticleCounts& counts) const;
  241.         void ClearCounts()
  242.         {
  243.                 ZeroStruct(m_Counts);
  244.         }
  245.  
  246.         void GetMemoryUsage(ICrySizer* pSizer) const;
  247.  
  248.         //////////////////////////////////////////////////////////////////////////
  249.         // IParticleVertexCreator methods
  250.  
  251.         virtual void ComputeVertices(const SCameraInfo& camInfo, CREParticle* pRE, uint64 uVertexFlags, float fMaxPixels);
  252.  
  253.         // Other methods.
  254.         bool NeedsUpdate() const;
  255.  
  256.         // functions for particle generate and culling of vertices directly into Video Memory
  257.         int  CullParticles(SParticleVertexContext& Context, int& nVertices, int& nIndices, uint8 auParticleAlpha[]);
  258.         void WriteVerticesToVMEM(SParticleVertexContext& Context, SRenderVertices& RenderVerts, const uint8 auParticleAlpha[]);
  259.  
  260.         void SetNeedJobUpdate(uint8 n)
  261.         {
  262.                 m_nNeedJobUpdate = n;
  263.         }
  264.         uint8 NeedJobUpdate() const
  265.         {
  266.                 return m_nNeedJobUpdate;
  267.         }
  268.         bool WasRenderedPrevFrame() const
  269.         {
  270.                 return m_nNeedJobUpdate > 0;
  271.         }
  272.  
  273.         int GetEmitterCount() const
  274.         {
  275.                 return m_Emitters.size();
  276.         }
  277.  
  278.         void OffsetPosition(const Vec3& delta);
  279.         void OnHidden();
  280.         void OnUnhidden();
  281.  
  282. private:
  283.         const ResourceParticleParams*      m_pParams;     // Pointer to particle params (effect or code).
  284.         _smart_ptr<CParticleEffect>        m_pEffect;     // Particle effect used for this emitter.
  285.         uint32                             m_nEnvFlags;
  286.         uint32                             m_nChildFlags; // Summary of rendering/environment info for child containers.
  287.  
  288.         ParticleList<CParticleSubEmitter>  m_Emitters;                    // All emitters into this container.
  289.         ParticleList<EmitParticleData>     m_DeferredEmitParticles;       // Data for client EmitParticles calls, deferred till next update.
  290.         ParticleList<_smart_ptr<IStatObj>> m_ExternalStatObjs;            // Any StatObjs from EmitParticle; released on destruction.
  291.  
  292.         uint16                             m_nHistorySteps;
  293.         uint16                             m_nEmitterSequence;
  294.  
  295.         ParticleList<CParticle>            m_Particles;
  296.  
  297.         CRenderObject*                     m_pBeforeWaterRO[RT_COMMAND_BUF_COUNT];
  298.         CRenderObject*                     m_pAfterWaterRO[RT_COMMAND_BUF_COUNT];
  299.         CRenderObject*                     m_pRecursiveRO[RT_COMMAND_BUF_COUNT];
  300.  
  301.         // Last time when emitter updated, and static bounds validated.
  302.         float m_fAgeLastUpdate;
  303.         float m_fAgeStaticBoundsStable;
  304.         float m_fContainerLife;
  305.  
  306.         // Final bounding volume for rendering. Also separate static & dynamic volumes for sub-computation.
  307.         AABB  m_bbWorld, m_bbWorldStat, m_bbWorldDyn;
  308.  
  309.         bool  m_bUnused;                                            // Temp var used during param editing.
  310.         uint8 m_nNeedJobUpdate;                                     // Mark container as needing sprite rendering this frame.
  311.                                                                     // Can be set to >1 to prime for threaded update next frame.
  312.  
  313.         // Associated structures.
  314.         CParticleContainer* m_pParentContainer;                     // Parent container, if indirect.
  315.         CParticleEmitter*   m_pMainEmitter;                         // Emitter owning this container.
  316.         float               m_fMaxParticleFullLife;                 // Cached value indicating max update time necessary.
  317.  
  318.         SContainerCounts    m_Counts;                               // Counts for stats.
  319.  
  320.         void  ComputeStaticBounds(AABB& bb, bool bWithSize = true, float fMaxLife = fHUGE);
  321.  
  322.         float GetEmitterLife() const;
  323.         float GetMaxParticleScale() const;
  324.         int   GetMaxParticleCount(const SParticleUpdateContext& context) const;
  325.         void  UpdateParticleStates(SParticleUpdateContext& context);
  326.         void  SetScreenBounds(const CCamera& cam, uint8 aScreenBounds[4]);
  327.  
  328.         CRenderObject* CreateRenderObject(uint64 nObjFlags);
  329.         void           ResetRenderObjects();
  330. };
  331.  
  332. #endif // __particlecontainer_h__
  333.  
downloadParticleContainer.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