BVB Source Codes

CRYENGINE Show ParticleComponent.h Source code

Return Download CRYENGINE: download ParticleComponent.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  Created:     29/01/2015 by Filipe amim
  5. //  Description:
  6. // -------------------------------------------------------------------------
  7. //
  8. ////////////////////////////////////////////////////////////////////////////
  9.  
  10. #ifndef PARTICLECOMPONENT_H
  11. #define PARTICLECOMPONENT_H
  12.  
  13. #pragma once
  14.  
  15. #include "ParticleCommon.h"
  16. #include "ParticleContainer.h"
  17. #include "Features/ParamTraits.h"
  18.  
  19. namespace pfx2
  20. {
  21.  
  22. SERIALIZATION_ENUM_DECLARE(EAnimationCycle, : uint8,
  23.                            Once,
  24.                            Loop,
  25.                            Mirror
  26.                            )
  27.  
  28. struct STextureAnimation
  29. {
  30.         TValue<float, USoftLimit<60>>       m_frameRate;     //!< Anim framerate; 0 = 1 cycle / particle life.
  31.         TValue<uint16, THardLimits<1, 256>> m_frameCount;    //!< Number of tiles (frames) of animation
  32.         EAnimationCycle                     m_cycleMode;     //!< How animation cycles.
  33.         bool                                m_frameBlending; //!< Blend textures between frames.
  34.  
  35.         // To do: Add random and curve modifiers
  36.  
  37.         STextureAnimation()
  38.                 : m_cycleMode(EAnimationCycle::Once), m_frameBlending(true), m_ageScale(1.0f), m_animPosScale(1.0f)
  39.         {
  40.         }
  41.  
  42.         bool IsAnimating() const
  43.         {
  44.                 return m_frameCount > 1;
  45.         }
  46.         bool HasAbsoluteFrameRate() const
  47.         {
  48.                 return m_frameRate > 0.0f;
  49.         }
  50.         float GetAnimPosAbsolute(float age) const
  51.         {
  52.                 // Select anim frame based on particle age.
  53.                 float animPos = age * m_ageScale;
  54.                 switch (m_cycleMode)
  55.                 {
  56.                 case EAnimationCycle::Once:
  57.                         animPos = min(animPos, 1.f);
  58.                         break;
  59.                 case EAnimationCycle::Loop:
  60.                         animPos = mod(animPos, 1.f);
  61.                         break;
  62.                 case EAnimationCycle::Mirror:
  63.                         animPos = 1.f - abs(mod(animPos, 2.f) - 1.f);
  64.                         break;
  65.                 }
  66.                 return animPos * m_animPosScale;
  67.         }
  68.         float GetAnimPosRelative(float relAge) const
  69.         {
  70.                 return relAge * m_animPosScale;
  71.         }
  72.  
  73.         void Serialize(Serialization::IArchive& ar);
  74.  
  75. private:
  76.         float m_ageScale;
  77.         float m_animPosScale;
  78.  
  79.         void  Update();
  80. };
  81.  
  82. SERIALIZATION_ENUM_DEFINE(EIndoorVisibility, ,
  83.         IndoorOnly,
  84.         OutdoorOnly,
  85.         Both
  86.         )
  87.  
  88. SERIALIZATION_ENUM_DEFINE(EWaterVisibility, ,
  89.         AboveWaterOnly,
  90.         BelowWaterOnly,
  91.         Both
  92.         )
  93.  
  94. struct SVisibilityParams
  95. {
  96.         UFloat m_viewDistanceMultiple;         // Multiply standard view distance calculated from max particle size and e_ParticlesMinDrawPixels
  97.         UFloat m_maxScreenSize;                // Override cvar e_ParticlesMaxDrawScreen, fade out near camera
  98.         UFloat m_minCameraDistance;
  99.         UFloat m_maxCameraDistance;
  100.         EIndoorVisibility m_indoorVisibility;
  101.         EWaterVisibility  m_waterVisibility;
  102.  
  103.         SVisibilityParams()
  104.                 : m_viewDistanceMultiple(1.0f)
  105.                 , m_maxScreenSize(2.0f)
  106.                 , m_indoorVisibility(EIndoorVisibility::Both)
  107.                 , m_waterVisibility(EWaterVisibility::Both)
  108.         {}
  109. };
  110.  
  111. struct SComponentParams
  112. {
  113.         SComponentParams();
  114.         SComponentParams(const CParticleComponent& component);
  115.  
  116.         void  Serialize(Serialization::IArchive& ar);
  117.  
  118.         void  Reset();
  119.         void  Validate(CParticleComponent* pComponent, Serialization::IArchive* ar = 0);
  120.         float GetPrimeTime() const;
  121.         bool  IsValid() const     { return m_isValid; }
  122.         bool  HasChildren() const { return !m_subComponentIds.empty(); }
  123.         bool  IsSecondGen() const { return m_parentId != gInvalidId; }
  124.         void  MakeMaterial(CParticleComponent* pComponent);
  125.  
  126.         // PFX2_TODO : Reorder from larger to smaller
  127.         const CParticleComponent* m_pComponent;
  128.         SParticleShaderData       m_shaderData;
  129.         _smart_ptr<IMaterial>     m_pMaterial;
  130.         _smart_ptr<IMeshObj>      m_pMesh;
  131.         string                    m_diffuseMap;
  132.         uint64                    m_renderObjectFlags;
  133.         size_t                    m_instanceDataStride;
  134.         STextureAnimation         m_textureAnimation;
  135.         float                     m_scaleParticleCount;
  136.         float                     m_baseParticleLifeTime;
  137.         float                     m_maxParticleSize;
  138.         float                     m_renderObjectSortBias;
  139.         SVisibilityParams         m_visibility;
  140.         size_t                    m_particleRange;
  141.         int                       m_renderStateFlags;
  142.         std::vector<TComponentId> m_subComponentIds;
  143.         TComponentId              m_parentId;
  144.         uint8                     m_particleObjFlags;
  145.         bool                      m_meshCentered;
  146.         bool                      m_isValid;
  147. };
  148.  
  149. class CParticleComponent : public IParticleComponent
  150. {
  151. public:
  152.         CParticleComponent();
  153.  
  154.         // IParticleComponent
  155.         virtual void                                     SetChanged() override;
  156.         virtual void                                     SetEnabled(bool enabled) override { SetChanged(); m_enabled.Set(enabled); }
  157.         virtual bool                                     IsEnabled() const override        { return m_enabled; }
  158.         virtual bool                                     IsVisible() const override        { return m_visible; }
  159.         virtual void                                     SetVisible(bool visible) override { m_visible.Set(visible); }
  160.         virtual void                                     Serialize(Serialization::IArchive& ar) override;
  161.         virtual void                                     SetName(const char* name) override;
  162.         virtual const char*                              GetName() const override        { return m_name.c_str(); }
  163.         virtual uint                                     GetNumFeatures() const override { return m_features.size(); }
  164.         virtual IParticleFeature*                        GetFeature(uint featureIdx) const override;
  165.         virtual void                                     AddFeature(uint placeIdx, const SParticleFeatureParams& featureParams) override;
  166.         virtual void                                     RemoveFeature(uint featureIdx) override;
  167.         virtual void                                     SwapFeatures(const uint* swapIds, uint numSwapIds) override;
  168.         virtual Vec2                                     GetNodePosition() const override;
  169.         virtual void                                     SetNodePosition(Vec2 position) override;
  170.  
  171.         const SRuntimeInitializationParameters&          GetRuntimeInitializationParameters() const                                   { return m_runtimeInitializationParameters; };
  172.         void                                             SetRuntimeInitializationParameters(SRuntimeInitializationParameters& params) { m_runtimeInitializationParameters = params; }
  173.         virtual gpu_pfx2::IParticleFeatureGpuInterface** GetGpuUpdateList(EUpdateList list, int& size) const override;
  174.         // ~IParticleComponent
  175.  
  176.         void                                  PreCompile();
  177.         void                                  ResolveDependencies();
  178.         void                                  Compile();
  179.         void                                  FinalizeCompile();
  180.  
  181.         TComponentId                          GetComponentId() const        { return m_componentId; }
  182.         CParticleEffect*                      GetEffect() const             { return m_pEffect; }
  183.         uint                                  GetNumFeatures(EFeatureType type) const;
  184.         CParticleFeature*                     GetCFeature(size_t idx) const { return m_features[idx]; }
  185.         template<typename TFeatureType>
  186.         TFeatureType*                         GetCFeatureByType() const;
  187.         CParticleFeature*                     GetCFeatureByType(const SParticleFeatureParams* pSearchParams) const;
  188.  
  189.         void                                  AddToUpdateList(EUpdateList list, CParticleFeature* pFeature);
  190.         TInstanceDataOffset                   AddInstanceData(size_t size);
  191.         void                                  AddParticleData(EParticleDataType type);
  192.         const std::vector<CParticleFeature*>& GetUpdateList(EUpdateList list) const { return m_updateLists[list]; }
  193.  
  194.         const SComponentParams& GetComponentParams() const                    { return m_componentParams; }
  195.         bool                    UseParticleData(EParticleDataType type) const { return m_useParticleData[type]; }
  196.  
  197.         bool                    SetSecondGeneration(CParticleComponent* pParentComponent);
  198.         CParticleComponent*     GetParentComponent() const;
  199.  
  200.         void                    PrepareRenderObjects(CParticleEmitter* pEmitter);
  201.         void                    ResetRenderObjects(CParticleEmitter* pEmitter);
  202.         void                    Render(CParticleEmitter* pEmitter, ICommonParticleComponentRuntime* pRuntime, const SRenderContext& renderContext);
  203.         void                    RenderDeferred(CParticleEmitter* pEmitter, ICommonParticleComponentRuntime* pRuntime, const SRenderContext& renderContext);
  204.         bool                    CanMakeRuntime(CParticleEmitter* pEmitter) const;
  205.  
  206. private:
  207.         friend class CParticleEffect;
  208.         Vec2                                                 m_nodePosition;
  209.         CParticleEffect*                                     m_pEffect;
  210.         TComponentId                                         m_componentId;
  211.         string                                               m_name;
  212.         SComponentParams                                     m_componentParams;
  213.         std::vector<TParticleFeaturePtr>                     m_features;
  214.         std::vector<CParticleFeature*>                       m_updateLists[EUL_Count];
  215.         std::vector<gpu_pfx2::IParticleFeatureGpuInterface*> m_gpuUpdateLists[EUL_Count];
  216.         StaticEnumArray<bool, EParticleDataType>             m_useParticleData;
  217.         TParticleFeaturePtr                                  m_defaultMotionFeature;
  218.         SEnable                                              m_enabled;
  219.         SEnable                                              m_visible;
  220.         bool                                                 m_dirty;
  221.  
  222.         SRuntimeInitializationParameters                     m_runtimeInitializationParameters;
  223. };
  224.  
  225. template<typename TFeatureType>
  226. ILINE TFeatureType* CParticleComponent::GetCFeatureByType() const
  227. {
  228.         const SParticleFeatureParams* pSearchParams = &TFeatureType::GetStaticFeatureParams();
  229.         return static_cast<TFeatureType*>(GetCFeatureByType(pSearchParams));
  230. }
  231.  
  232. }
  233.  
  234. #endif // PARTICLECOMPONENT_H
  235.  
downloadParticleComponent.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