particle.h

#pragma once

#include "animated.h"
#include "util/ParaMemPool.h"
#include "FileManager.h"
#include <list>
#include <map>


namespace ParaEngine
{
class ParticleSystem;
class RibbonEmitter;
class Bone;
class CParaXModel;
struct TextureEntity;

struct Particle {
    Vector3 pos, speed, down, origin;
    //Vector3 tpos;
    float size, life, maxlife, random_force, trail_length;
    float rotation, rotSpeed;
    int tile;
    Vector4 color;
};

typedef FixedSizedAllocator<Particle>   DL_Allocator_ParticleList;
typedef std::list<Particle, DL_Allocator_ParticleList > ParticleListType;
struct  ParticleList
{
    ParticleListType particles;
    bool m_bUseAbsCord:1;
    Vector3 m_vLastRenderOrigin;
    bool m_bUpdated:1;
    bool m_bRender:1;
    int m_anim;
    int m_time;
    float m_rem;
    void * m_pSceneState;
public:
    ParticleList():m_pSceneState(NULL),m_bUseAbsCord(true), m_vLastRenderOrigin(0,0,0),m_bUpdated(false),m_anim(0), m_time(0),m_rem(0){};
};

class ParticleEmitter {
protected:
    ParticleSystem *sys;
public:
    enum{
        TYPE_NONE=0,
        TYPE_PLANE_PARTICLE_EMITTER=1,
        TYPE_SPHERE_PARTICLE_EMITTER=2,
    };
    ParticleEmitter(ParticleSystem *sys): sys(sys) {}
    virtual ~ParticleEmitter() {};
    virtual Particle newParticle(int anim, int time) = 0;
    virtual int GetEmitterType()=0;
};

class PlaneParticleEmitter: public ParticleEmitter {
public:
    PlaneParticleEmitter(ParticleSystem *sys): ParticleEmitter(sys) {}
    virtual ~PlaneParticleEmitter() {};
    Particle newParticle(int anim, int time);
    virtual int GetEmitterType(){return (int)TYPE_PLANE_PARTICLE_EMITTER;};
};

class SphereParticleEmitter: public ParticleEmitter {
public:
    SphereParticleEmitter(ParticleSystem *sys): ParticleEmitter(sys) {}
    virtual ~SphereParticleEmitter() {};
    Particle newParticle(int anim, int time);
    virtual int GetEmitterType(){return (int)TYPE_SPHERE_PARTICLE_EMITTER;};
};

struct TexCoordSet {
    Vector2 tc[4];
};
class ParticleSystem 
{
    friend class PlaneParticleEmitter;
    friend class SphereParticleEmitter;
public: 
    Animated<float> speed;
    Animated<float> variation;
    Animated<float> gravity;
    Animated<float> lifespan;
    Animated<float> rate;
    Animated<float> areal;
    Animated<float> areaw;

    Animated<float> spread;
    Animated<float> lat;
    Animated<float> grav2;
    

    float slowdown;
    
    // this parameter is only used for sphere emitter type It is the angle between the emitting direction and downward direction in range [-Pi/2, Pi/2]. Default value is 0, which is the downward direction like the plane emitter.
    float rotation;

    float mid;
    Vector4 colors[3];
    float sizes[3];

    Vector3 pos;
    
    int blend;
    int order;
    int type;

    bool billboard;

    // a new particle will use a random image at one of the rows*cols regions in the texture accociated with the particle system.
    // if rows=1, cols=1, the entire texture is used.
    int rows, cols;
    // this is automatically generated from rows, cols
    std::vector<TexCoordSet> tiles; 
    // the texture associated with this particle system.
    int32 m_texture_index;
    
    // the bone to which the particle system is attached.
    Bone *parent;

    // the emitter object
    ParticleEmitter *emitter;

public:
    // the ParaX model in which the particle system is defined (contained).
    CParaXModel *model;

    float tofs;

    map <void*, ParticleList*> m_instances;

    bool rotate2SpeedDirection;
public:
    ParticleSystem();
    ~ParticleSystem();

    // update existing particles and spawn new ones
    void update(SceneState * pSceneState, float dt);

    void ClearAllInstances();

    DeviceTexturePtr_type GetDeviceTexture();
    TextureEntity* GetTexture();

    bool AnimateExistingParticles(float dt, const Vector3& vOffset, ParticleList* instancePS);

    ParticleList* GetCurrentInstance(SceneState * pSceneState, bool bForceCreate=true);

    bool DeleteInstance(void * owner);

    void setup(SceneState * pSceneState, int anim, int time);
    void draw(SceneState * pSceneState);
    void drawInstance(ParticleList* instancePS);
    void drawAllAbsInstances();

    CParaXModel * GetParent() {return model;}

    // only called by drawInstance();
    void DrawInstanceSub(ParticleList* instancePS);
    void SetTextureRowsCols(int nRows, int nCols);
};

struct RibbonSegment {
    Vector3 pos, up, back;
    float len,len0;
};

class RibbonEmitter 
{
public:
    Animated<Vector3> color;
    AnimatedShort opacity;
    Animated<float> above, below;

    Bone *parent;
    float f1, f2;

    Vector3 pos;

    int manim, mtime;
    float length, seglen;
    int numsegs;
    
    Vector3 tpos;
    Vector4 tcolor;
    float tabove, tbelow;
    bool m_bUseAbsCord:1;

    int32 m_texture_index;

    std::list<RibbonSegment> segs;

public:
    CParaXModel *model;
    RibbonEmitter() :m_bUseAbsCord(true), m_texture_index(0){};

    void setup(SceneState * pSceneState, int anim, int time);
    void draw(SceneState * pSceneState);


    DeviceTexturePtr_type GetDeviceTexture();
    TextureEntity* GetTexture();
};
}