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

#include "dxstdafx.h"
#include ".\particlegroup.h"
#include "ParticleEmitter.h"
#include "GameManager.h"

ParticleGroup::ParticleGroup(void) : Node()
{
        this->useGravity(true);
        this->nodeType |= Scene::NODE_PARTICLEGROUP;
        this->useHeatHaze = false;
}

ParticleGroup::~ParticleGroup(void)
{
}

void ParticleGroup::addParticle(SPTR<Node> particle)
{
        if(!particle->isA(Scene::NODE_PARTICLEEMITTER)) {
                particle->setParticleGroup(this->particleGroup);
        } else {
                this->myScene->manager->printToConsole("Have not set the ParticleGroup to Emitter!");
        }
        particle->getFather()->removeChild(particle);
        this->addChild(particle);
        
        if(this->hasRenderer()) {
                if(particle->hasRenderer()) {
                        particle->removeRenderer();
                }
        }
        if(particle->getActor()!=NULL && !this->gravity) {
                particle->getActor()->raiseBodyFlag(NX_BF_DISABLE_GRAVITY);
        }
}

void ParticleGroup::addParticleEmitter(SPTR<Node> particleEmitter) {
        ParticleEmitter* e = (ParticleEmitter*) particleEmitter.get();
        e->setParticleGroup(this);
        this->useHeatHaze |= e->getUseHeatHaze();
        this->emitterList.push_back(e);
}

void ParticleGroup::removeParticleEmitter(ParticleEmitter* particleEmitter) {
        for(UINT i=0;i<this->emitterList.size();i++) {
                if(this->emitterList.at(i)==particleEmitter) {
                        this->emitterList.erase((this->emitterList.begin()+i));
                }
        }
        if(this->emitterList.size()==0 && this->children.size()==0) {
                this->killMe();
        }
}

void ParticleGroup::setParticleGroup(int _group)
{
        this->particleGroup = _group;
}

void ParticleGroup::useGravity(bool _gravity)
{
        this->gravity = _gravity;
}

void ParticleGroup::removeChild(std::list<SPTR<Node> >::iterator _it)
{
        this->children.remove((SPTR<Node>) *_it);
        if(this->emitterList.size()==0 && this->children.size()==0) {
                this->killMe();
        }
}

void ParticleGroup::removeChild(SPTR<Node> _child)
{
        this->children.remove(_child);
        if(this->emitterList.size()==0 && this->children.size()==0) {
                this->killMe();
        }
}

void ParticleGroup::killMe() 
{
        for(UINT i=0;i<this->emitterList.size();i++) {
                this->emitterList.at(i)->killMe();
        }
        Node::killMe();
}

void ParticleGroup::setUseHeatHaze(bool _useHeatHaze)
{
        this->useHeatHaze = _useHeatHaze;
}

bool ParticleGroup::getUseHeatHaze()
{
        return this->useHeatHaze;
}

void ParticleGroup::updateBBox() {
        std::list<SPTR<Node> >::iterator it;
        std::list<SPTR<Node> >::iterator itEnd;
        Node* node;
        itEnd = this->children.end();
        if(this->calcBoundingBox) {
                Vector childMinBBox(9999999,9999999,9999999);
                Vector childMaxBBox(-9999999,-9999999,-9999999);
                
                for(it=this->children.begin();it!=itEnd;it++) {
                        node = (*it).get();
                        if(!node->onStandBy() && node->isVisible()) {
                                node->updateBBox();
                        }
                }
                bool first = true;
                for(it=this->children.begin();it!=itEnd;it++) {
                        node = (*it).get();
                        if(!node->onStandBy() && node->isVisible() &&
                                node->absMinAABBox.x!=0 && node->absMinAABBox.y!=0 && node->absMinAABBox.z!=0) {
                                        if(first) {
                                                first = false;
                                                this->minAABBox = node->absMinAABBox;
                                                this->maxAABBox = node->absMaxAABBox;
                                        }
                                //min
                                childMinBBox.x = (childMinBBox.x < node->absMinAABBox.x) ? childMinBBox.x : node->absMinAABBox.x;
                                childMinBBox.y = (childMinBBox.y < node->absMinAABBox.y) ? childMinBBox.y : node->absMinAABBox.y;
                                childMinBBox.z = (childMinBBox.z < node->absMinAABBox.z) ? childMinBBox.z : node->absMinAABBox.z;

                                //max
                                childMaxBBox.x = (childMaxBBox.x > node->absMaxAABBox.x) ? childMaxBBox.x : node->absMaxAABBox.x;
                                childMaxBBox.y = (childMaxBBox.y > node->absMaxAABBox.y) ? childMaxBBox.y : node->absMaxAABBox.y;
                                childMaxBBox.z = (childMaxBBox.z > node->absMaxAABBox.z) ? childMaxBBox.z : node->absMaxAABBox.z;
                        }
                }
                
                corner[0] = this->minAABBox;
                corner[1] = this->minAABBox; corner[1].x = this->maxAABBox.x;
                corner[2] = this->maxAABBox; corner[2].y = this->minAABBox.y;
                corner[3] = this->minAABBox; corner[3].z = this->maxAABBox.z;
                corner[4] = this->minAABBox; corner[4].y = this->maxAABBox.y;
                corner[5] = this->maxAABBox; corner[5].z = this->minAABBox.z;
                corner[6] = this->maxAABBox;
                corner[7] = this->maxAABBox; corner[7].x = this->minAABBox.x;
                for(int i=0;i<8;i++) {
                        this->getAbsoluteVector(corner[i], corner[i]);
                        //min
                        childMinBBox.x = (childMinBBox.x < corner[i].x) ? childMinBBox.x : corner[i].x;
                        childMinBBox.y = (childMinBBox.y < corner[i].y) ? childMinBBox.y : corner[i].y;
                        childMinBBox.z = (childMinBBox.z < corner[i].z) ? childMinBBox.z : corner[i].z;

                        childMaxBBox.x = (childMaxBBox.x > corner[i].x) ? childMaxBBox.x : corner[i].x;
                        childMaxBBox.y = (childMaxBBox.y > corner[i].y) ? childMaxBBox.y : corner[i].y;
                        childMaxBBox.z = (childMaxBBox.z > corner[i].z) ? childMaxBBox.z : corner[i].z;
                }
                this->absMinAABBox = childMinBBox;
                this->absMaxAABBox = childMaxBBox;
                this->absBoxCenter = (this->absMinAABBox + this->absMaxAABBox)/2;
        } else {
                for(it=this->children.begin();it!=itEnd;it++) {
                        node = (*it).get();
                        if(!node->onStandBy() && node->isVisible()) {
                                node->updateBBox();
                        }
                }
        }
}