particle_effect.cpp

Go to the documentation of this file.

//            Copyright (C) 2004-2007 by The Allacrost Project
//                         All Rights Reserved
//
// This code is licensed under the GNU GPL version 2. It is free software 
// and you may modify it and/or redistribute it under the terms of this license.
// See http://www.gnu.org/copyleft/gpl.html for details.

#include "particle_effect.h"
#include "particle_system.h"
#include "video.h"
#include "script.h"

using namespace std;
using namespace hoa_script;
using namespace hoa_video::private_video;

namespace hoa_video
{


//-----------------------------------------------------------------------------
// ParticleEffect
//-----------------------------------------------------------------------------

ParticleEffect::ParticleEffect()
{
  _alive = false;
  _x = _y = 0.0f;
  _attractor_x = _attractor_y = 0.0f;
  _age = 0.0f;
  _effect_def = NULL;
  _orientation = 0.0f;
}


//-----------------------------------------------------------------------------
// _Draw: draws the effect. This is called by ParticleManager, not by API user
//-----------------------------------------------------------------------------

bool ParticleEffect::_Draw()
{
  bool success = true;

  // move to the effect's location
  VideoManager->Move(_x, _y);

  list<ParticleSystem *>::iterator iSystem = _systems.begin();
  
  while(iSystem != _systems.end())
  {
    VideoManager->PushMatrix();
    if(!(*iSystem)->Draw())
    {
      VideoManager->PopMatrix();
      success = false;      
      if(VIDEO_DEBUG)
        cerr << "VIDEO ERROR: failed to draw system in ParticleEffect::_Update()" << endl;
    }   
    
    VideoManager->PopMatrix();
    ++iSystem;
  }
  
  glDisable(GL_STENCIL_TEST);
  glDisable(GL_ALPHA_TEST);
  glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

  
  return success;
}


//-----------------------------------------------------------------------------
// Update: updates particle effect. Called by ParticleManager, not by user.
//-----------------------------------------------------------------------------

bool ParticleEffect::_Update(float frame_time)
{
  _age += frame_time;
  _num_particles = 0;
  
  if(!_alive)
    return true;
  
  bool success = true;

  private_video::EffectParameters effect_parameters;
  effect_parameters.orientation = _orientation;
  
  // note we subtract the effect position to put the attractor point in effect
  // space instead of screen space
  effect_parameters.attractor_x = _attractor_x - _x;
  effect_parameters.attractor_y = _attractor_y - _y;

  list<ParticleSystem *>::iterator iSystem = _systems.begin();  
  
  while(iSystem != _systems.end())
  {
    if(!(*iSystem)->IsAlive())
    {
      (*iSystem)->Destroy();
      iSystem = _systems.erase(iSystem);

      if(_systems.empty())
        _alive = false;
    }
    else 
    {
      if(!(*iSystem)->Update(frame_time, effect_parameters))
      {
        success = false;
        if(VIDEO_DEBUG)
          cerr << "VIDEO ERROR: failed to update system in ParticleEffect::_Update()" << endl;        
      }
      
      _num_particles += (*iSystem)->GetNumParticles();      
      ++iSystem;
    }
  }

  return success;
}


//-----------------------------------------------------------------------------
// Destroy: destroys the effect. Called by ParticleManager during _Update(), if
//          this effect is not alive (i.e. IsAlive() returns false)
//-----------------------------------------------------------------------------

void ParticleEffect::_Destroy()
{
  list<ParticleSystem *>::iterator iSystem = _systems.begin();
  
  while(iSystem != _systems.end())
  {
    (*iSystem)->Destroy();
    ++iSystem;
  }
}


//-----------------------------------------------------------------------------
// Move: function for the API user to move the effect around to different
//       locations
//-----------------------------------------------------------------------------

void ParticleEffect::Move(float x, float y)
{
  _x = x;
  _y = y;
}


//-----------------------------------------------------------------------------
// MoveRelative: function for API user to move the effect relative to its current
//            position
//-----------------------------------------------------------------------------

void ParticleEffect::MoveRelative(float dx, float dy)
{
  _x += dx;
  _y += dy;
}


//-----------------------------------------------------------------------------
// SetOrientation: sets the orientation of the effect, which is added to the
//                 orientation for each of the emitters
//-----------------------------------------------------------------------------

void ParticleEffect::SetOrientation(float angle)
{
  _orientation = angle;
}


//-----------------------------------------------------------------------------
// SetAttractorPoint: set the location of an attractor point. Any systems with
//                    radial acceleration and user-defined attractor points
//                    enabled will have particles gravitate toward this point
//-----------------------------------------------------------------------------

void ParticleEffect::SetAttractorPoint(float x, float y)
{
  _attractor_x = x;
  _attractor_y = y;
}


//-----------------------------------------------------------------------------
// IsAlive: returns true if effect is still alive. Used by ParticleManager
//          so it knows when to destroy an effect.
//-----------------------------------------------------------------------------

bool ParticleEffect::IsAlive()
{
  return _alive;
}


//-----------------------------------------------------------------------------
// Stop: stops the effect. If kill_immediate is true, then the effect is stopped
//       immediately. Otherwise, the particles which are still alive are allowed
//       to keep drawing, but no new particles are emitted.
//-----------------------------------------------------------------------------

void ParticleEffect::Stop(bool kill_immediate)
{
  if(kill_immediate)
  {
    // just set _alive to false, and the particle manager will remove it for us
    _alive = false;
  }
  else
  {
    // if we're not killing immediately, then calling Stop() just means to stop emitting NEW
    // particles, so go through each system and turn off its emitter
    
    list<ParticleSystem *>::iterator iSystem = _systems.begin();
    
    while(iSystem != _systems.end())
    {
      (*iSystem)->Stop();
      ++iSystem;
    }   
  }
}


//-----------------------------------------------------------------------------
// GetNumParticles: returns the number of live particles for the entire effect
//-----------------------------------------------------------------------------

int32 ParticleEffect::GetNumParticles() const
{
  return _num_particles;  
}


//-----------------------------------------------------------------------------
// GetPosition: returns the current position of the effect
//-----------------------------------------------------------------------------

void ParticleEffect::GetPosition(float &x, float &y) const
{
  x = _x;
  y = _y;
}


//-----------------------------------------------------------------------------
// GetAge: returns the current age of the effect, i.e. how many seconds it has
//         been since the effect was created
//-----------------------------------------------------------------------------

float ParticleEffect::GetAge() const
{
  return _age;
}


} // namespace hoa_video

---