source: orxonox.OLD/orxonox/trunk/src/lib/particles/particle_emitter.cc @ 4439

/* 
   orxonox - the future of 3D-vertical-scrollers

   Copyright (C) 2004 orx

   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, or (at your option)
   any later version.

   ### File Specific:
   main-programmer: Benjamin Grauer
   co-programmer: Patrick Boenzli
*/

#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_PARTICLE

#include "particle_emitter.h"

#include "particle_system.h"
#include "particle_engine.h"

#include "load_param.h"
#include "debug.h"
#include "stdlibincl.h"

using namespace std;


/**
   \brief standard constructor
*/
ParticleEmitter::ParticleEmitter(const Vector& direction, float angle, float emissionRate, 
                  float velocity)
{
  this->type = EMITTER_DOT;
  this->emitterSize = 1.0;
  this->direction = direction;
  this->setSpread(angle);
  this->setEmissionRate(emissionRate);
  this->setEmissionVelocity(velocity);
}

ParticleEmitter::ParticleEmitter(const TiXmlElement* root)
{
   this->setClassID(CL_PARTICLE_EMITTER, "ParticleEmitter");

   this->saveTime = 0.0;

   if (root)
     this->loadParams(root);

   ParticleEngine::getInstance()->addEmitter(this);
}

/**
   \brief standard destructor

*/
ParticleEmitter::~ParticleEmitter () 
{
  ParticleEngine::getInstance()->removeEmitter(this);
}

void ParticleEmitter::loadParams(const TiXmlElement* root)
{
  static_cast<PNode*>(this)->loadParams(root);

  LoadParam<ParticleEmitter>(root, "type", this, &ParticleEmitter::setType)
    .describe("What type of emitter is this [dot, plane, cube, sphere].");

  LoadParam<ParticleEmitter>(root, "size", this, &ParticleEmitter::setSize)
    .describe("How big the emitter is (no effect on dot-emitters)");

  LoadParam<ParticleEmitter>(root, "rate", this, &ParticleEmitter::setEmissionRate)
    .describe("How many particles should be emittet from this emitter");

  LoadParam<ParticleEmitter>(root, "emission-velocity", this, &ParticleEmitter::setEmissionVelocity)
    .describe("How fast the particles are emittet (their initial speed)");
  
  LoadParam<ParticleEmitter>(root, "spread", this, &ParticleEmitter::setSpread)
    .describe("The angle the particles are emitted from (angle, deviation)");

}

/**
   \brief this start the emitter
*/
void ParticleEmitter::start() {}


/**
   \brief this stops the emitter
*/
void ParticleEmitter::stop() {}




/* these are Animation interfaces: so you can change spec values as you want */

/**
   \param type the new Type of this emitter
*/
void ParticleEmitter::setType(EMITTER_TYPE type)
{
  this->type = type;
}

/**
   \param the type of emitter
*/
void ParticleEmitter::setType(const char* type)
{
  if (!strcmp(type, "plane"))
    this->type = EMITTER_PLANE;
  else if (!strcmp(type, "cube"))
    this->type = EMITTER_CUBE;
  else if (!strcmp(type, "sphere"))
    this->type = EMITTER_SPHERE;
  else
    this->type = EMITTER_DOT;
}


void ParticleEmitter::setSize(float emitterSize)
{
  if (emitterSize > 0.0)
    this->emitterSize = emitterSize;
  else
    emitterSize = 0.0;
}

/**
   \brief set the emission rate
   \param sets the number of particles emitted per second

   if you want to change the value of this variable during emission time (to make it more dynamic)
   you may want to use the animation class
*/
void ParticleEmitter::setEmissionRate(float emissionRate)
{
  if (emissionRate > 0.0)
    this->emissionRate = emissionRate;
  else
    this->emissionRate = 0.0;
}

/**
   \brief set the angle of the emitter
   \param angle around the direction in which there are particles to be emitted
   \param randomAngle A random spread-angle, the +- randomness of this option

   if you want to change the value of this variable during emission time (to make it more dynamic)
   you may want to use the animation class
*/
void ParticleEmitter::setSpread(float angle, float randomAngle)
{
  this->angle = angle;
  this->randomAngle = randomAngle;
}

/**
   \brief sets the velocity of all particles emitted
   \param velocity The starting velocity of the emitted particles
   \param random A random starting velocity, the +- randomness of this option

   if you want to change the value of this variable during emission time (to make it more dynamic)
   you may want to use the animation class
*/
void ParticleEmitter::setEmissionVelocity(float velocity, float randomVelocity)
{
  this->velocity = velocity;
  this->randomVelocity = randomVelocity;
}

/**
   \brief this set the time to life of a particle, after which it will die
   \param the time to live in seconds

   if you want to change the value of this variable during emission time (to make it more dynamic)
   you may want to use the animation class
*/

void ParticleEmitter::tick(float dt, ParticleSystem* system)
{
  if (likely(dt > 0.0 && this->emissionRate > 0.0))
  {
    // saving the time
    float count = (dt+this->saveTime) * this->emissionRate;
    this->saveTime = modff(count, &count) / this->emissionRate;
    PRINTF(5)("emitting %f particles, saving %f seconds for the next round\n", count, this->saveTime); 
    
    if (likely(count > 0))
      {
        Vector inheritVelocity = this->getVelocity() * system->inheritSpeed;
        for (int i = 0; i < count; i++)
          // emmits from EMITTER_DOT,
          {
            Vector randDir = Vector(rand()-RAND_MAX/2, rand()-RAND_MAX/2, rand()-RAND_MAX/2);
            randDir.normalize();
            randDir = (this->getAbsDir()*Quaternion(angle + randomAngle *((float)rand()/RAND_MAX -.5), randDir)).apply(this->direction);
            Vector velocityV = randDir.getNormalized()*this->velocity + inheritVelocity;

            // this should spread the Particles evenly. if the Emitter is moved around quickly
            Vector equalSpread = this->getVelocity() * rand()/RAND_MAX * dt;
            Vector extension; // the Vector for different fields.

            if (this->type & 2)
              {
                extension = Vector(this->emitterSize * ((float)rand()/RAND_MAX -.5), 0, this->emitterSize * ((float)rand()/RAND_MAX - .5));
                extension = this->getAbsDir().apply(extension);
              }
            else if (this->type & 8)
              {
                extension = Vector((float)rand()/RAND_MAX -.5, (float)rand()/RAND_MAX -.5, (float)rand()/RAND_MAX -.5) * this->emitterSize;
              }

            system->addParticle(this->getAbsCoor() + extension - equalSpread, velocityV);
            
          }
      }
  }
}

/**
   \brief outputs some nice debug information
*/
void ParticleEmitter::debug(void)
{

}