fsCParticleData.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           fsCParticleData.h
*       
*       Purpose:        Shared instance of particle parameters.
*
*********************************************************************/
 
#ifndef fsCParticleDatahdr
#define fsCParticleDatahdr
 
#include <memory>
 
#include <fsCore/fsStr.h>
#include <fsCore/fsVec2d.h>
#include <fsCore/fsPoint.h>
#include <fsCore/fsSColour.h>
 
#include <fsAppCore/src/fsCGraph.h>
 
#include "fsCParticleDataInstance.h"
#include "fsCParticleCloud.h"
 
class fsIParticle;
struct fsPoint;
class fsIAnimationData;
class fsCEntity;
class fsCParticleScaleParameter;
class fsCParticleRotateParameter;
class fsCBrush;
 
 
class fsCParticleData
{
        friend class fsCParticleDataLoader;
 
public:
 
        struct fsSOscillationGraph
        {
                fsSOscillationGraph();
                fsF32 valueGet(fsS32 pTime);
                fsS32 periodGet() const;
                
                void offsetSet();
                void rangeSet(fsF32 pOscillationRange, fsF32 pTimeRange);
                void dataAdd(fsS32 pDuration, fsF32 pOffset);
                
                std::shared_ptr<fsCGraph<fsF32>> mGraph;
                fsF32 mOscillationRange;
                fsF32 mTimeRange;
                fsF32 mOscillationOffset;
                fsF32 mTimeOffset;
        };
 
        struct fsSParticleEmmitParams
        {
                fsSParticleEmmitParams(std::vector<std::unique_ptr<fsIParticle>>& pParticleCache,
                                       const fsPoint& pSpawnPosition,
                                       fsCEntity* const pParentEnt,
                                       fsS32 pNumToEmit,
                                       fsBool pPreRunPhase,
                                       fsIParticleCloud* pSpawnCloud) :
                        mParticleCache(pParticleCache),
                        mSpawnPosition(pSpawnPosition),
                        mParentEnt(pParentEnt),
                        mNumToEmit(pNumToEmit),
                        mPreRunPhase(pPreRunPhase),
                        mSpawnCloud(pSpawnCloud)
                {
                }
 
                std::vector<std::unique_ptr<fsIParticle>>& mParticleCache;
                const fsPoint& mSpawnPosition;
                fsCEntity* const mParentEnt;
                fsS32 mNumToEmit;
                fsBool mPreRunPhase;
                fsIParticleCloud* mSpawnCloud;
        };
 
        static fsF32 rndF32Get(fsS32 pRange);
 
    fsBool pulseGet() const { return mPulse; }
        fsS32 preRunPhaseTimeGet() const { return mPrerunMs; }
 
        fsS32 emitterLifetimeGet() const { return mEmitterLifeMs; }
 
        fsS32 lifetimeGet() const { return mParticleLifeMs; }
        fsS32 maxParticlesGet() const { return mMaxParticles; }
        fsF32 particlesEmitPerSecondGet() const { return mEmitSpeedPerSec; }
 
        fsStr const& collectablTypeGet() const { return mCollectableType; }
        fsS32 collectableCountGet() const { return mCollectableCount; }
        fsBool linkedToEmitterGet() const { return mLinkToEmitter; }
 
        fsS32 particlesEmit(const fsSParticleEmmitParams& pEmmitParams) const;
    
        void particleCacheCreate(std::vector<std::unique_ptr<fsIParticle>>& pParticleCache, fsS32 pMaxParticles);
 
        fsCParticleData(const fsCParticleData&) = delete;
 
        fsCParticleData();
 
        virtual ~fsCParticleData();
 
protected:
 
private:
 
        std::unique_ptr<fsIParticle> particleParticleCreate() const;
        std::unique_ptr<fsIParticle> animationParticleCreate() const;
        std::unique_ptr<fsIParticle> spriteParticleCreate() const;
 
        fsVec2d parentEntBasedStartPosGet(fsCEntity* pParentEnt) const;
 
        void particleReset(fsIParticle* pParticle, fsS32 pIndex, const fsSParticleEmmitParams& pEmmitParams) const;
        void particlePosReset(fsIParticle* pParticle, fsS32 pIndex, const fsSParticleEmmitParams& pEmmitParams) const;
        void particleScaleReset(fsIParticle* pParticle) const;
        void particleAngleReset(fsIParticle* pParticle) const;
 
        static fsVec2d rndVec2Get(const fsPoint& pRange);
        void scaleYCreate();
 
        void emmiterLoad(const fsCResourceName& pParticleDataFilename);
        void brushLoad(const fsCResourceName& pBrushFileName);
        void animDataLoad(const fsCResourceName& pAnimFileName);
        void sfxFileNameSet(const fsStr& pFileName);
 
 
        fsVec2d mPivot;
 
        fsVec2d mVelocityUV;
 
        fsCParticleScaleParameter* mScaleX;
        fsCParticleScaleParameter* mScaleY;
        fsCParticleRotateParameter* mAngle;
 
 
    fsBool mPulse;
        fsStr mCollectableType;
        fsS32 mCollectableCount;
 
        fsBool mLinkToEmitter;
        fsS32 mMaxParticles;
        fsS32 mParticleLifeMs;
        fsF32 mEmitSpeedPerSec;
 
        fsVec2d mEmitPos;
        fsPoint mEmitPosRange;
        fsVec2d mVelocity;
        fsPoint mVelocityRange;
        fsVec2d mVelocityDelta;
        fsPoint mVelocityDeltaRange;
 
        fsS32 mAlphaBlendMode;
 
        fsS32 mPrerunMs;
 
        fsS32 mEmitterLifeMs;
 
        fsSColour mColour;
        
        std::shared_ptr<fsSOscillationGraph> mHorizontalOscillationGraph;
        std::shared_ptr<fsSOscillationGraph> mVerticalOscillationGraph;
        fsCGraph<fsSColour>* mColourGraph;
 
        std::vector<std::shared_ptr<fsCBrush>> mSprBrush;
        std::vector<std::shared_ptr<fsCBrush>>::iterator mCurrentSprBrush;
 
        std::shared_ptr<fsIAnimationData> mAnimData;
        fsCParticleDataInstance mParticleParticleData;
 
        fsStr mSFXFileName;
 
#if !defined fsRELEASE
        fsStr mFileName;
#endif
};
 
#endif