BVB Source Codes

CRYENGINE Show Particle.h Source code

Return Download CRYENGINE: download Particle.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef PARTICLE_H
  4. #define PARTICLE_H
  5.  
  6. #include "ParticleEffect.h"
  7. #include "ParticleMemory.h"
  8. #include "ParticleEnviron.h"
  9. #include "ParticleUtils.h"
  10. #include <CryRenderer/RenderElements/CREParticle.h>
  11.  
  12. class CParticleContainer;
  13. class CParticleSubEmitter;
  14. class CParticleEmitter;
  15. struct SParticleRenderData;
  16. struct SParticleVertexContext;
  17. struct SParticleUpdateContext;
  18. struct SLocalRenderVertices;
  19. struct STargetForces;
  20.  
  21. //////////////////////////////////////////////////////////////////////////
  22. #define fMAX_COLLIDE_DEVIATION 0.1f
  23. #define fMAX_DENSITY_ADJUST    32.f
  24.  
  25. // dynamic particle data
  26. // To do opt: subclass for geom particles.
  27.  
  28. //////////////////////////////////////////////////////////////////////////
  29. struct STimeState
  30. {
  31. protected:
  32.         float m_fAge;                       // Current age.
  33.         float m_fStopAge;                   // Age of death.
  34.         float m_fCollideAge;                // Age of first collision (for SpawnOnCollision children).
  35.  
  36. public:
  37.         STimeState()
  38.                 : m_fAge(0.f), m_fStopAge(0.f), m_fCollideAge(fHUGE) {}
  39.  
  40.         float GetAge() const
  41.         { return m_fAge; }
  42.         float GetStopAge() const
  43.         { return m_fStopAge; }
  44.         float GetCollideAge() const
  45.         { return m_fCollideAge; }
  46.  
  47.         float GetRelativeAge(float fAgeAdjust = 0.f) const
  48.         {
  49.                 float fRelativeAge = div_min(max(m_fAge + fAgeAdjust, 0.f), m_fStopAge, 1.f);
  50.                 assert(fRelativeAge >= 0.f && fRelativeAge <= 1.f);
  51.                 return fRelativeAge;
  52.         }
  53.         bool IsAlive(float fAgeAdjust = 0.f) const
  54.         { return m_fAge + fAgeAdjust < m_fStopAge; }
  55.  
  56.         void Start(float fAgeAdjust = 0.f)
  57.         { m_fAge = -fAgeAdjust; m_fStopAge = m_fCollideAge = fHUGE; }
  58.         void Stop(float fAgeAdjust = 0.f)
  59.         { m_fStopAge = min(m_fStopAge, m_fAge + fAgeAdjust); }
  60.         void Collide(float fAgeAdjust = 0.f)
  61.         { m_fCollideAge = m_fAge + fAgeAdjust; }
  62.         void Kill()
  63.         { m_fStopAge = -fHUGE; }
  64. };
  65.  
  66. struct SMoveState
  67. {
  68. protected:
  69.         QuatTS    m_Loc;            // Position, orientation, and size.
  70.         float     m_fAngle;         // Scalar angle, for camera-facing rotation.
  71.         Velocity3 m_Vel;            // Linear and rotational velocity.
  72.  
  73. public:
  74.         SMoveState()
  75.                 : m_Loc(IDENTITY), m_fAngle(0.0f), m_Vel(ZERO) {}
  76.  
  77.         QuatTS const&    GetLocation() const
  78.         { return m_Loc; }
  79.         Velocity3 const& GetVelocity() const
  80.         { return m_Vel; }
  81.         Vec3             GetVelocityAt(Vec3 const& vWorldPos) const
  82.         { return m_Vel.VelocityAt(vWorldPos - m_Loc.t); }
  83.  
  84.         void PreTransform(QuatTS const& qp)
  85.         {
  86.                 m_Loc = m_Loc * qp;
  87.                 m_Vel.vLin = m_Vel.vLin * qp.q * qp.s;
  88.                 m_Vel.vRot = m_Vel.vRot * qp.q;
  89.         }
  90.         void Transform(QuatTS const& qp)
  91.         {
  92.                 m_Loc = qp * m_Loc;
  93.                 m_Vel.vLin = qp.q * m_Vel.vLin * qp.s;
  94.                 m_Vel.vRot = qp.q * m_Vel.vRot;
  95.         }
  96.         void OffsetPosition(const Vec3& delta)
  97.         {
  98.                 m_Loc.t += delta;
  99.         }
  100. };
  101.  
  102. struct SParticleState : STimeState, SMoveState
  103. {
  104.         friend class CParticle;
  105. };
  106.  
  107. //////////////////////////////////////////////////////////////////////////
  108. class CRY_ALIGN(16) CParticleSource: public Cry3DEngineBase, public _plain_reference_target<int>, public SParticleState, public GeomRef
  109. {
  110. public:
  111.  
  112.         CParticleSource()
  113.                 : m_pEmitter(0)
  114.         {
  115.         }
  116.  
  117.         const CParticleSubEmitter* GetEmitter() const
  118.         { return m_pEmitter; }
  119.         const GeomRef&             GetEmitGeom() const
  120.         { return *this; }
  121.  
  122.         using _plain_reference_target<int>::AddRef;
  123.         using _plain_reference_target<int>::Release;
  124.  
  125. protected:
  126.  
  127.         CParticleSubEmitter* m_pEmitter;              // Parent emitter, if this is a child emitter.
  128. };
  129.  
  130. //////////////////////////////////////////////////////////////////////////
  131. class CRY_ALIGN(32) CParticle: public CParticleSource
  132. {
  133. public:
  134.  
  135.         ~CParticle();
  136.  
  137.         void Init(SParticleUpdateContext const & context, float fAge, CParticleSubEmitter * pEmitter, const EmitParticleData &data);
  138.         void Update(SParticleUpdateContext const & context, float fUpdateTime, bool bNew = false);
  139.         void GetPhysicsState();
  140.  
  141.         float GetMinDist(Vec3 const& vP) const
  142.         {
  143.                 static const float fSizeFactor = 1.0f;
  144.                 return (m_Loc.t - vP).GetLengthFast() - m_Loc.s * fSizeFactor;
  145.         }
  146.  
  147.         float GetAlphaMod() const
  148.         {
  149.                 return GetParams().fAlpha.GetValueFromBase(m_BaseMods.Alpha, GetRelativeAge());
  150.         }
  151.  
  152.         ILINE uint16 GetEmitterSequence() const
  153.         {
  154.                 return m_nEmitterSequence;
  155.         }
  156.  
  157.         void Hide()
  158.         {
  159.                 // Disable rendering.
  160.                 m_BaseMods.Alpha = 0;
  161.         }
  162.  
  163.         void UpdateBounds(AABB & bb, SParticleState const & state) const;
  164.         void UpdateBounds(AABB& bb) const
  165.         {
  166.                 UpdateBounds(bb, *this);
  167.         }
  168.         void OffsetPosition(const Vec3 &delta);
  169.  
  170.         Vec3 GetVisualVelocity(SParticleState const & state, float fTime = 0.f) const;
  171.  
  172.         // Associated structures.
  173.         CParticleContainer&           GetContainer() const
  174.         { return *m_pContainer; }
  175.         CParticleSource&              GetSource() const;
  176.         CParticleEmitter&             GetMain() const;
  177.         ResourceParticleParams const& GetParams() const;
  178.  
  179.         // Rendering functions.
  180.         bool RenderGeometry(SRendParams & RenParamsShared, SParticleVertexContext & context, const SRenderingPassInfo &passInfo) const;
  181.         void AddLight(const SRendParams &RenParams, const SRenderingPassInfo &passInfo) const;
  182.         void SetVertices(SLocalRenderVertices & alloc, SParticleVertexContext & context, uint8 uAlpha) const;
  183.         void GetTextureRect(RectF & rectTex, Vec3 & vTexBlend) const;
  184.         void ComputeRenderData(SParticleRenderData & RenderData, const SParticleVertexContext &context, float fObjectSize = 1.f) const;
  185.         float ComputeRenderAlpha(const SParticleRenderData &RenderData, float fRelativeAge, SParticleVertexContext & context) const;
  186.         void GetRenderMatrix(Vec3 & vX, Vec3 & vY, Vec3 & vZ, Vec3 & vT, const QuatTS &loc, const SParticleRenderData &RenderData, const SParticleVertexContext &context) const;
  187.         void GetRenderMatrix(Matrix34& mat, const QuatTS& loc, const SParticleRenderData& RenderData, const SParticleVertexContext& context) const
  188.         {
  189.                 Vec3 av[4];
  190.                 GetRenderMatrix(av[0], av[1], av[2], av[3], loc, RenderData, context);
  191.                 mat.SetFromVectors(av[0], av[1], av[2], av[3]);
  192.         }
  193.         void SetVertexLocation(SVF_Particle& Vert, const QuatTS& loc, const SParticleRenderData& RenderData, const SParticleVertexContext& context) const
  194.         {
  195.                 Vec3 vZ;
  196.                 GetRenderMatrix(Vert.xaxis, vZ, Vert.yaxis, Vert.xyz, loc, RenderData, context);
  197.         }
  198.  
  199. #ifdef PARTICLE_EDITOR_FUNCTIONS
  200.         void UpdateAllocations(int nPrevHistorySteps);
  201. #endif
  202.         static size_t GetAllocationSize(const CParticleContainer * pCont);
  203.         void GetMemoryUsage(ICrySizer* pSizer) const { /*nothing*/ }
  204.  
  205. private:
  206.  
  207.         //////////////////////////////////////////////////////////////////////////
  208.         // For particles with tail, keeps history of previous locations.
  209.         struct CRY_ALIGN(16) SParticleHistory
  210.         {
  211.                 float fAge;
  212.                 QuatTS Loc;
  213.  
  214.                 bool IsUsed() const { return fAge >= 0.f; }
  215.                 void SetUnused()    { fAge = -1.f; }
  216.         };
  217.  
  218.         // Track sliding state.
  219.         struct SSlideInfo
  220.         {
  221.                 _smart_ptr<IPhysicalEntity>
  222.                       pEntity;              // Physical entity hit.
  223.                 Vec3  vNormal;              // Normal of sliding surface.
  224.                 float fFriction;            // Sliding friction, proportional to normal force.
  225.                 float fSlidingTime;         // Cumulative amount of time sliding.
  226.  
  227.                 SSlideInfo()
  228.                 { Clear(); }
  229.                 void Clear()
  230.                 { ClearSliding(Vec3(ZERO)); }
  231.                 void ClearSliding(const Vec3& vNormal_)
  232.                 {
  233.                         pEntity = 0;
  234.                         fFriction = 0;
  235.                         fSlidingTime = -1.f;
  236.                         vNormal = vNormal_;
  237.                 }
  238.                 void SetSliding(IPhysicalEntity* pEntity_, const Vec3& vNormal_, float fFriction_)
  239.                 {
  240.                         pEntity = pEntity_;
  241.                         vNormal = vNormal_;
  242.                         fFriction = fFriction_;
  243.                         fSlidingTime = 0.f;
  244.                 }
  245.                 bool IsSliding() const
  246.                 { return fSlidingTime >= 0.f; }
  247.         };
  248.  
  249.         // Track predicted collisions.
  250.         struct SHitInfo
  251.         {
  252.                 Vec3  vPos;                   // Hit position.
  253.                 Vec3  vPathDir;               // Direction of reverse path.
  254.                 float fPathLength;            // Length of reverse path.
  255.                 Vec3  vNormal;                // Normal of hit surface.
  256.                 _smart_ptr<IPhysicalEntity>
  257.                       pEntity;                // Physical entity hit.
  258.                 int   nSurfaceIdx;            // Surface index of hit; -1 if no hit.
  259.  
  260.                 SHitInfo()
  261.                 { Clear(); }
  262.                 void Clear()
  263.                 {
  264.                         nSurfaceIdx = -1;
  265.                         fPathLength = 0.f;
  266.                         pEntity = 0;
  267.                 }
  268.  
  269.                 bool HasPath() const
  270.                 { return fPathLength > 0.f; }
  271.                 bool HasHit() const
  272.                 { return nSurfaceIdx >= 0; }
  273.                 void SetMiss(const Vec3& vStart_, const Vec3& vEnd_)
  274.                 { SetHit(vStart_, vEnd_, Vec3(0.f)); }
  275.                 void SetHit(const Vec3& vStart_, const Vec3& vEnd_, const Vec3& vNormal_, int nSurfaceIdx_ = -1, IPhysicalEntity* pEntity_ = 0)
  276.                 {
  277.                         vPos = vEnd_;
  278.                         vPathDir = vStart_ - vEnd_;
  279.                         fPathLength = vPathDir.GetLength();
  280.                         if (fPathLength > 0.f)
  281.                                 vPathDir /= fPathLength;
  282.                         vNormal = vNormal_;
  283.                         nSurfaceIdx = nSurfaceIdx_;
  284.                         pEntity = pEntity_;
  285.                 }
  286.  
  287.                 // If path invalid, returns false.
  288.                 // If path valid returns true; if hit.dist < 1, then hit was matched.
  289.                 bool TestHit(ray_hit& hit, const Vec3& vPos0, const Vec3& vPos1, const Vec3& vVel0, const Vec3& vVel1, float fMaxDev, float fRadius = 0.f) const;
  290.         };
  291.  
  292.         struct SCollisionInfo
  293.         {
  294.                 SSlideInfo Sliding;
  295.                 SHitInfo   Hit;
  296.                 int32      nCollisionLeft;          // Number of collisions this particle is allowed to have: max = unlimited; 0 = no collide, -1 = stop
  297.  
  298.                 SCollisionInfo(int32 nMaxCollisions = 0)
  299.                         : nCollisionLeft(nMaxCollisions ? nMaxCollisions : 0x7FFFFFFF) {}
  300.  
  301.                 void Clear()
  302.                 {
  303.                         Sliding.Clear();
  304.                         Hit.Clear();
  305.                 }
  306.  
  307.                 int32 Collide()
  308.                 { return --nCollisionLeft; }
  309.                 void  Stop()
  310.                 { nCollisionLeft = -1; }
  311.                 bool  CanCollide() const
  312.                 { return nCollisionLeft > 0; }
  313.                 bool  Stopped() const
  314.                 { return nCollisionLeft < 0; }
  315.         };
  316.  
  317.         // Constant values.
  318.  
  319.         SParticleHistory* m_aPosHistory;                // History of positions, for tail. Allocated and maintained by particle.
  320.         SCollisionInfo* m_pCollisionInfo;               // Predicted collision info.
  321.  
  322.         // Base modifications (random variation, emitter strength) for this particle of variable parameters.
  323.         // Stored as compressed fraction from 0..1.
  324.         struct SBaseMods
  325.         {
  326.                 // Random modifiers for unsigned params.
  327.                 TFixed<uint8, 1>
  328.                 Size,
  329.                   Aspect,
  330.                   StretchOrTail,                            // Used for either stretch or tail (exclusive features)
  331.  
  332.                   AirResistance,
  333.                   Turbulence3DSpeed,
  334.                   TurbulenceSize,
  335.  
  336.                   LightSourceIntensity,
  337.                   LightSourceRadius,
  338.                   Alpha;
  339.  
  340.                 // Random modifiers for signed params.
  341.                 TFixed<int8, 1>
  342.                 PivotX,
  343.                   PivotY,
  344.                   GravityScale,
  345.                   TurbulenceSpeed,
  346.                   fTargetRadius;
  347.  
  348.                 Color3B Color;
  349.  
  350.                 void    Init()
  351.                 {
  352.                         memset(this, 0xFF, sizeof(*this));
  353.                 }
  354.         } m_BaseMods;
  355.  
  356.         uint8 m_nTileVariant;                           // Selects texture tile.
  357.  
  358.         uint16 m_nEmitterSequence : 15,                 // Which sequence particle is part of (for connected rendering).
  359.                m_bFlippedTexture : 1;                   // Reverse texture U.
  360.  
  361.         // External references.
  362.         CParticleContainer* m_pContainer;       // Container particle lives in.
  363.  
  364.         // Functions.
  365. private:
  366.  
  367.         void        SetState(SParticleState const& state) { static_cast<SParticleState&>(*this) = state; }
  368.         float       GetBaseRadius() const                 { return GetParams().GetMaxObjectSize(GetMesh()); }
  369.         float       GetVisibleRadius() const              { assert(m_Loc.s >= 0.f); return m_Loc.s * GetBaseRadius(); }
  370.         float       GetPhysicalRadius() const             { return GetVisibleRadius() * GetParams().fThickness; }
  371.         inline Vec3 GetNormal() const                     { return m_Loc.q.GetColumn1(); }
  372.  
  373.         void InitPos(SParticleUpdateContext const & context, QuatTS const & loc, float fEmissionRelAge);
  374.         Vec3 GenerateOffset(SParticleUpdateContext const & context);
  375.  
  376.         void AddPosHistory(SParticleState const & stateNew);
  377.         void AlignTo(SParticleState & state, const Vec3 &vNormal) const;
  378.         float UpdateAlignment(SParticleState & state, SParticleUpdateContext const & context, Plane const & plWater, float fTime = 0.f) const;
  379.         Vec3 VortexRotation(SParticleState const & state, bool bVelocity, float fTime = 0.f) const;
  380.         void TargetMovement(ParticleTarget const & target, SParticleState & state, float fTime, float fRelativeAge) const;
  381.         float TravelSlide(SParticleState & state, SSlideInfo & sliding, float fTime, const Vec3 &vExtAccel, float fMaxSlide, float fMinStepTime) const;
  382.         void Move(SParticleState & state, float fTime, STargetForces const & forces) const;
  383.         float MoveLinear(SParticleState & state, SCollisionInfo & coll, float fTime, STargetForces const & forces, float fMaxLinearDev, float fMaxSlideDev, float fMinStepTime) const;
  384.         bool CheckCollision(ray_hit & hit, float fTime, SParticleUpdateContext const & context, const STargetForces &forces, const SParticleState &stateNew, SCollisionInfo & collNew);
  385.  
  386.         void Physicalize();
  387.         int GetSurfaceIndex() const;
  388.         void GetCollisionParams(int nCollSurfaceIdx, float& fElasticity, float& fDrag) const;
  389.  
  390.         void SetTailVertices(const SVF_Particle &BaseVert, SParticleRenderData RenderData, SLocalRenderVertices & alloc, SParticleVertexContext const & context) const;
  391.  
  392.         void DebugBounds(SParticleState const & state) const
  393. #if defined(_DEBUG)
  394.         ;
  395. #else
  396.         {}
  397. #endif
  398.  
  399. };
  400.  
  401. #endif // PARTICLE
  402.  
downloadParticle.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