particle.h

/*--License:
        Lilith 3D Engine
        Copyright Lee Thomason (Grinning Lizard Software) 2002-2003
        www.grinninglizard.com/lilith

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with this program; if not, write to the Free Software
        Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

        The full text of the license can be found in license.txt
*/
#ifndef LILITH_PARTICLE_INCLUDED
#define LILITH_PARTICLE_INCLUDED

#ifdef _MSC_VER
#pragma warning( disable : 4786 )       // Debugger truncating names.
#endif
#include <list>
#include "mesh.h"
#include "../grinliz/glrandom.h"
#include "../grinliz/glcolor.h"

namespace lilith3d
{

class Texture;

class ParticleSystem : public MeshGroup
{
  public:
        virtual void DoTick() = 0;
        virtual ~ParticleSystem();

        virtual const char* SystemName() = 0;
        virtual int PrepareStreamOut() = 0;

        // Used by most systems.
        virtual void StreamOut( const Shader* shader, ELightPass light, EPass pass );

  protected:
        ParticleSystem();
        void Init( int count, const Texture* tex );

        int maxNumVertex;
        const Texture*  texture;
        grinliz::Vector3F*      quads;
        grinliz::Color4F*       color;
        grinliz::Vector2F*      texUV;
};


class GravParticles : public ParticleSystem
{
  public:
        GravParticles();
        ~GravParticles();

        enum
        {
                CIRCULAR_WHITE,         
                FLAME0,                         
                FLAME1,                         

                FLAME_COUNT = 2,
        };

        virtual const char* SystemName()        { return "GravParticles"; }

        void Create( const grinliz::Vector3F& location,
                                 const grinliz::Vector3F& velocity,
                                 const grinliz::Color3F& color,
                                 float gravity,
                                 float size,
                                 int type = CIRCULAR_WHITE,
                                 float decay = DECAY );

        virtual void DoTick();
        virtual int PrepareStreamOut();

        virtual void DoCulling()                {}

        static const float FAST_DECAY;
        static const float DECAY;

        static const float GRAVITY;

        static const float VERYSMALL;
        static const float SMALL;
        static const float MEDIUM;
        static const float LARGE;

  private:
        void SwapParticle( int a, int b );

        enum {
                MAX_PARTICLE = 1024
        };

        struct Particle
        {
                grinliz::Vector3F loc;
                grinliz::Vector3F velocity;
                float gravity;
                float size;
                float decay;
        };
        int numParticle;
        Particle* particle;
};


class RainDropParticles : public ParticleSystem
{
  public:
        RainDropParticles();
        ~RainDropParticles();

        virtual const char* SystemName()        { return "RainDropParticles"; }

        void Rain( float intensity );
        virtual void DoTick();

        virtual void DoCulling();

        virtual void StreamOut( const Shader* shader, ELightPass light, EPass pass );
        virtual int PrepareStreamOut()                                                          { return 0; }

  private:
        static const float DROP_LENGTH;
        static const float DROP_VELOCITY;

        struct RainDrop 
        {
                grinliz::Vector3F pos;
                bool splash;
        };
        std::list< RainDrop > rainDropList;

        float intensity;
        grinliz::Random rand;
        U32 timeOfLastDrop;
};


class RainSplashParticles : public ParticleSystem
{
  public:
        RainSplashParticles();
        ~RainSplashParticles();

        virtual const char* SystemName()        { return "RainSplashParticles"; }

        void Create( const grinliz::Vector3F& location );
        virtual void DoTick();

        virtual void DoCulling()                {}

        virtual int PrepareStreamOut();

  private:
        static const float SPLASH_VELOCITY;
        static const float MAX_SIZE;
        enum {
                MAX_PARTICLE = 32
        };

        struct Splash 
        {
                float x, y, z;
                float size;
        };
        Splash* splash;
        int numSplash;
};
};

#endif

---