source: GTP/branches/IllumWPdeliver2008dec/IlluminationWP/demos/Standalone/Hierarchical Systems Demo [OpenGL]/RESOURCES/include/My3DGraphRes/ParticleEmitter.cpp @ 3255

#include ".\particleemitter.h"
#include <random.h>
#include <stdio.h>
#include <stdlib.h>
#include <fstream>
#ifdef WIN32
#include <windows.h>
#endif

using namespace std;

ParticleEmitter::ParticleEmitter(void)
{
        m_Position=Vector(0,0,0);
        m_Velocity=0.7;
        m_TimeToLive=4000;
        m_TTLvariation=2000;
        m_Size=0.7;
        m_EmissionRate=5; 
        m_Sizevariation=0.2;
        m_isDirectionSet=false;
        m_Direction=Vector(0,1,0);
        m_Radius=0.7;
        m_VelocityVariation=0.5;
        m_Type=0;
        m_Offset=0;
}

ParticleEmitter::~ParticleEmitter(void)
{
}

void ParticleEmitter::setPositionsFile(char* filename)
{
        m_Type=1;

        ifstream file;

        file.open(filename);

        char in[50];
        file>>in;//particlecount
        unsigned int count;
        file>>count;
        m_ScriptPositionCount=count;
        m_ScriptPositions=new Vector[count];
        file>>in;
        file>>in;

        for(unsigned int i=0;i<count;i++)
        {
                double pos;
                file>>pos;
                m_ScriptPositions[i].x=pos;
                file>>pos;
                m_ScriptPositions[i].y=pos;
                file>>pos;
                m_ScriptPositions[i].z=pos;
        }

        file.close();

}

unsigned int ParticleEmitter::Emit(unsigned int Dt,unsigned int maxcount,Particle* particles,Vector CamPos)
{
        //Dt= ms

        //how much to emit?
        unsigned int toemit=Dt*m_EmissionRate/1000-m_EmittedInSecond;
        
        if(toemit>maxcount||m_EmissionRate==0)
        {
                toemit=maxcount;
        }
        //emit particles
        m_EmittedInSecond+=toemit;

        Particle* thisParticle=particles;
        /*
        Halton Halton1(1,11);
        Halton Halton2(1,23);
        Halton Halton3(1,19);
        */      
        for(unsigned int i=0;i<toemit;i++)
        {
                Particle* newParticle=new Particle;
                //fill the properties

                //add direction

                //calculate random dir
/*      
                double angle1=RangeRandom(-M_PI,M_PI);
                double angle2=RangeRandom(-M_PI,M_PI);
                        
                Vector randpoint(cos(angle1)*cos(angle2),
                                                        sin(angle2),
                                                        sin(angle1)*cos(angle2));
        */
        /*      Vector randpoint((double)Halton1.Random(),
                                                        (double)Halton2.Random(),
                                                        (double)Halton3.Random());
*/
        //      randpoint.Normalize();
                Vector randpoint(RangeRandom(-1,1),RangeRandom(-1,1),RangeRandom(-1,1));
        //      randpoint.Normalize();

                

                //set position
                if(m_Type==0)
                {
                        if(m_Radius==0)
                        {
                                newParticle->setPosition(m_Position);
                        }
                        else
                        {
                                randpoint.Normalize();
                                newParticle->setPosition(m_Position+randpoint*m_Radius*UnitRandom());
                        }
                }
                else//get particle from script positions
                {
                        int randindex=(rand())%m_ScriptPositionCount;
                        newParticle->setPosition(m_Position+m_ScriptPositions[randindex]*m_Radius+randpoint*m_Offset);
                        randpoint.Normalize();
                }
        
                if(m_VelocityVariation>1)m_VelocityVariation=1;
                if(m_VelocityVariation<0)m_VelocityVariation=0;
                double v=RangeRandom(-m_VelocityVariation,m_VelocityVariation);
                double vel=m_Velocity+v*m_Velocity;

                if(m_isDirectionSet)
                {
                        newParticle->setVelocity(m_Direction*vel);
                }
                else
                {
                        
                        newParticle->setVelocity(randpoint*vel);

                }

                newParticle->m_Distance=(newParticle->getPosition()-CamPos).Length();

                //add time to live
                unsigned int ttl;
                if(m_TimeToLive!=0)
                {
                ttl=(unsigned int)RangeRandom(m_TimeToLive-m_TTLvariation,m_TimeToLive+m_TTLvariation);
                newParticle->refrcol=true;
                }
                else
                {
                ttl=0;
                }
                newParticle->setTimetoLive(ttl);

                //set size
                if(m_Sizevariation>1)m_Sizevariation=1;
                if(m_Sizevariation<0)m_Sizevariation=0;
                double s=RangeRandom(-m_Sizevariation,m_Sizevariation);
                double siz=m_Size+s*m_Size;
                //newParticle->setSize(siz);
                newParticle->setSize(RangeRandom(m_Size-m_Sizevariation*m_Size,m_Size+m_Sizevariation*m_Size));

                newParticle->Refresh(0);
                
                thisParticle->m_NextParticle=newParticle;
                thisParticle=thisParticle->m_NextParticle;
        }

        if(Dt>1000)
        {
                //new second begins
                m_EmittedInSecond=0;
        }
        
        return toemit;
}