source: GTP/trunk/App/Games/Jungle_Rumble/src/ParticleEmitter.cpp @ 1378

#include "dxstdafx.h"
#include ".\particleemitter.h"
#include "ParticleGroup.h"
#include "GameManager.h"

ParticleEmitter::ParticleEmitter(void) : ParticleCube() {
        this->width = 2;
        this->height = 2;
        this->depth = 1;
        this->pid = 0;
        this->updatePlanes();
        this->setEMBirthRate(10);
        this->setEMEmissionDuration(10);
        this->setEMParticleVelocity(10);
        this->setEMHorizontalDegree(0.3f);
        this->setEMVerticalDegree(0.3f);
        this->setEMParticleLifeTime(5);
        this->setEMRotationalDegree(50, 50, 50);
        this->firstFrame = true;
        this->deleteMe = true;
        this->emitting = false;
        this->useHeatHaze = false;
        this->nodeType |= Scene::NODE_PARTICLEEMITTER;
        this->sound = NULL;
}

ParticleEmitter::~ParticleEmitter(void) {
}


void ParticleEmitter::setEMBirthRate(float _birthRate) {
        this->birthRate = _birthRate;
}

void ParticleEmitter::setEMEmissionDuration(float _emissionDur) {
        this->lifeTime = 0;
        this->nextEmit = 0;
        this->pid = 0;
        this->particleEmitted = 1;
        this->emissionDur = _emissionDur;
}

void ParticleEmitter::setEMParticleLifeTime(float _particleLifeTime) {
        this->particleLifeTime = _particleLifeTime;
}

void ParticleEmitter::setEMParticleVelocity(float _velocity) {
        this->velocity = _velocity;
}

void ParticleEmitter::setEMHorizontalDegree(float _horDegree) {
        this->horDegree = _horDegree;
}

void ParticleEmitter::setEMVerticalDegree(float _verDegree) {
        this->verDegree = _verDegree;
}

void ParticleEmitter::setEMRotationalDegree(float _rX, float _rY, float _rZ) {
        this->rotDegree.setXYZ(_rX, _rY, _rZ);
}

void ParticleEmitter::setDeleteMeAfterEmission(bool _deleteMe) {
        this->deleteMe = _deleteMe;
}

void ParticleEmitter::addRefNode(Node &node) {
        node.setVisible(false);
        node.setStandBy(true);
        this->refNodeVector.push_back(&node);
}

/*void ParticleEmitter::attachRefEmitter(PartikelEmitter &emitter) {
        this->refEmitter = &emitter;
}*/

void ParticleEmitter::update(float dt) {
        //PartikelCube::update(dt);
        if(this->firstFrame) {
                this->emitting = true;
                this->firstFrame = false;
                srand((UINT)time(NULL));
                if(this->sound) {
                        this->sound->play();
                }
                return;
        }
        this->lifeTime+=dt;

        if(this->lifeTime < this->emissionDur) {
                if(this->sound) {
                        this->sound->setPosition(this->getAbsolutePosition());
                }
                float dtEmission = 1/this->birthRate; //this->emissionDur/this->birthRate;
                int pCount = (int) (this->lifeTime/dtEmission);
                int n = pCount-this->particleEmitted;
                //ParticleEmitter *pEmitter;
                for(int i=0; i<n;i++) {
                        Node *node;
                        Node *refNode;

                        //pid = (int)((((float)rand())/RAND_MAX)*this->refNodeVector.size())-1;
                        pid = (int) ((((float) rand())/(RAND_MAX+1))*(this->refNodeVector.size()-1));
                        if(pid<0)
                                pid = 0;
                        if(pid>this->refNodeVector.size()-1)
                                pid = 0;

                        /*char temp[100];
                        sprintf(temp, "refNodeVector.size = %i", this->refNodeVector.size());
                        this->myScene->manager->printToConsole(temp);*/

                        if(this->refNodeVector.size()==0) {
                                this->myScene->manager->printToConsole("ParticleEmitter::refNodeVector.size = 0!!!");
                                return;
                        }
        
                        refNode = this->refNodeVector.at(pid);
                        node = refNode->clone();
                        this->myScene->addToParticleList(node);
                        node->setStandBy(false);

                        /*if(this->refEmitter!=NULL) {
                                pEmitter = this->sMgr->createPartikelEmitter(*node);
                                //Clone refEmitter
                                pEmitter->setEMBirthRate(this->refEmitter->birthRate);
                                pEmitter->setEMEmissionDuration(this->refEmitter->emissionDur);
                                pEmitter->setEMPartikelVelocity(this->refEmitter->velocity);
                                pEmitter->setEMHorizontalDegree(this->refEmitter->horDegree);
                                pEmitter->setEMVerticalDegree(this->refEmitter->verDegree);
                                pEmitter->setEMRotationalDegree(this->refEmitter->rotDegree.x, this->refEmitter->rotDegree.y, this->refEmitter->rotDegree.z);
                                pEmitter->setEMPartikelLifeTime(this->refEmitter->partikelLifeTime);
                                pEmitter->setDeleteMeAfterEmission(this->refEmitter->deleteEmitter);
                                pEmitter->refNodeVector = this->refEmitter->refNodeVector;
                                pEmitter->setDimensions(this->width, this->height, this->depth);
                        }*/

                        node->setVisible(true);
                        //node->setParticleGroup(this->getParticleGroup());
                        node->setTimeToLive(this->particleLifeTime);
                        this->myParticleGroup->addParticle(this->myScene->getSmartPointer(node));

                        node->setColDetGroup(this->pColDetGroup);

                        //Set Velocity
                        Vector v;
                        v.x = (FLOAT)(((float)rand())/RAND_MAX - 0.5)*2*this->horDegree;
                        v.y = (FLOAT)(((float)rand())/RAND_MAX - 0.5)*2*this->verDegree;
                        v.z = 1;        //StandardDirection
                        v.normalize();
                        v = v*this->velocity;
                        this->addVelocityToParticle(node, v);

                        //Set EmitPosition
                        Vector p;
                        p = this->getAbsolutePosition();
                        p.x += (FLOAT)(((float)rand())/RAND_MAX - 0.5)*this->width;
                        p.y += (FLOAT)(((float)rand())/RAND_MAX - 0.5)*this->height;
                        node->setPosition(p);

                        //Set Rotation
                        Vector rotP;
                        rotP.x = (FLOAT)(((float)rand())/RAND_MAX - 0.5)*this->rotDegree.x;
                        rotP.y = (FLOAT)(((float)rand())/RAND_MAX - 0.5)*this->rotDegree.y;
                        rotP.z = (FLOAT)(((float)rand())/RAND_MAX - 0.5)*this->rotDegree.z;
                        
                        node->getActor()->addLocalTorque(rotP.getNxVector());
                        node->getActor()->setSolverIterationCount(1);

                        this->particleEmitted++;
                }
        } else if(this->deleteMe) {
                this->killMe();
        } else {
                if(this->sound) {
                        this->sound->stop();
                }
                this->setStandBy(true);
        }
        if(this->lifeTime >= this->emissionDur) {
                if(this->sound) {
                        this->sound->stop();
                }
                this->emitting = false;
        }
}

void ParticleEmitter::restartEmitting()
{
        this->firstFrame = true;
        this->lifeTime = 0;
        this->nextEmit = 0;
        this->pid = 0;
        this->particleEmitted = 1;
        this->setStandBy(false);
}

bool ParticleEmitter::isEmitting() {
        return this->emitting;
}

void ParticleEmitter::killMe() {
        //this->myScene->manager->printToConsole("deleteEmitter!");
        for(UINT i=0;i<this->refNodeVector.size();i++) {
                //this->myScene->setTrigger(Scene::TRIGGER_KILLNODE, this->refNodeVector.at(i), sceneLifeTime + this->particleLifeTime + 0.5);
                this->refNodeVector.at(i)->killMe();
        }
        this->refNodeVector.clear();
        this->myParticleGroup->removeParticleEmitter(this);
        ParticleCube::killMe();
}

void ParticleEmitter::setParticleGroup(ParticleGroup* _particleGroup)
{
        this->myParticleGroup = _particleGroup;
        this->particleGroup = this->myParticleGroup->getParticleGroup(); //Diese Zeile könnte falsch sein!!
}

void ParticleEmitter::setUseHeatHaze(bool _use) 
{
        this->useHeatHaze = _use;
}
bool ParticleEmitter::getUseHeatHaze()
{
        return this->useHeatHaze;
}

Node* ParticleEmitter::clone()
{
        //this->myScene->manager->printToConsole("   cloning Emitter");
        ParticleGroup* pg = (ParticleGroup*) this->myScene->createNode(Scene::NODE_PARTICLEGROUP, this->myParticleGroup->hasRenderer());

        /*char temp[100];
        sprintf(temp, "      new ParticleGroupID = %i", pg->getParticleGroup());
        this->myScene->manager->printToConsole(temp);*/

        ParticleEmitter* obj = (ParticleEmitter*) this->myScene->createNode(Scene::NODE_PARTICLEEMITTER);
        
        obj->setDimensions(this->width, this->height, this->depth);
        obj->setEMBirthRate(this->birthRate);
        obj->setEMEmissionDuration(this->emissionDur);
        obj->setEMHorizontalDegree(this->horDegree);
        obj->setEMParticleLifeTime(this->particleLifeTime);
        obj->setEMParticleVelocity(this->velocity);
        obj->setEMRotationalDegree(this->rotDegree.x, this->rotDegree.y, this->rotDegree.z);
        obj->setDeleteMeAfterEmission(this->deleteMe);
        obj->setUseHeatHaze(this->useHeatHaze);
        obj->firstFrame = true;
        obj->lifeTime = 0;
        obj->pColDetGroup = this->pColDetGroup;

        //RefNodes!
        Node* node = NULL;
        for(UINT i=0;i<this->refNodeVector.size();i++) {
                //this->myScene->manager->printToConsole("      refNode cloned!");
                node = this->refNodeVector.at(i)->clone();
                node->setBehaveAs(Node::RIGIDBODY);
                node->setColDetGroup(this->pColDetGroup);
                obj->addRefNode(*node);
                //obj->addRefNode(*this->refNodeVector.at(i)->clone());
                //obj->addRefNode(*this->refNodeVector.at(i));
        }
        //ParticleGroup
        //this->myParticleGroup->addParticleEmitter(this->myScene->getSmartPointer(obj));
        pg->addParticleEmitter(this->myScene->getSmartPointer(obj));

        obj->pActorDesc = this->pActorDesc;
        obj->pBodyDesc = this->pBodyDesc;
        obj->pActorDesc.body = &obj->pBodyDesc;
        
        return obj;
}

void ParticleEmitter::addEmittingSound(SoundNode* _sound)
{
        this->sound = _sound;
        this->addChild(this->myScene->getSmartPointer(this->sound));
}