particle_manager.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_manager.h"
#include "particle_effect.h"
#include "particle_system.h"
#include "particle_keyframe.h"
#include "video.h"
#include "script.h"
#include <iostream>

extern "C" {
  #include <lua.h>
  #include <lauxlib.h>
  #include <lualib.h>
}


using namespace std;
using namespace hoa_script;
using namespace hoa_video;


#define LOAD_INT(str, var)  \
{ \
  lua_pushstring(L, str); \
  lua_gettable(L, -2); \
  if(!lua_isnumber(L, -1))  \
  {\
    if(VIDEO_DEBUG) \
      cerr << "VIDEO ERROR: could not load parameter " << str << " in ParticleManager::LoadEffect()!" << endl; \
    return false; \
  }\
  (var) = (int32)lua_tonumber(L, -1);\
  lua_pop(L, 1); \
}


#define LOAD_FLOAT(str, var)  \
{ \
  lua_pushstring(L, str); \
  lua_gettable(L, -2); \
  if(!lua_isnumber(L, -1))  \
  {\
    if(VIDEO_DEBUG) \
      cerr << "VIDEO ERROR: could not load parameter " << str << " in ParticleManager::LoadEffect()!" << endl; \
    return false; \
  }\
  (var) = (float)lua_tonumber(L, -1);\
  lua_pop(L, 1); \
}


#define LOAD_BOOL(str, var)  \
{ \
  lua_pushstring(L, str); \
  lua_gettable(L, -2); \
  if(!lua_isnumber(L, -1))  \
  {\
    if(VIDEO_DEBUG) \
      cerr << "VIDEO ERROR: could not load parameter " << str << " in ParticleManager::LoadEffect()!" << endl; \
    return false; \
  }\
  (var) = (bool)lua_tonumber(L, -1);\
  lua_pop(L, 1); \
}


#define LOAD_STRING(str, var)  \
{ \
  lua_pushstring(L, str); \
  lua_gettable(L, -2); \
  if(!lua_isstring(L, -1))  \
  {\
    if(VIDEO_DEBUG) \
      cerr << "VIDEO ERROR: could not load parameter " << str << " in ParticleManager::LoadEffect()!" << endl; \
    return false; \
  }\
  var = string(lua_tostring(L, -1));\
  lua_pop(L, 1); \
}


#define LOAD_COLOR(str, var)  \
{ \
  lua_pushstring(L, str); \
  lua_gettable(L, -2); \
  if(!lua_istable(L, -1))  \
  {\
    if(VIDEO_DEBUG) \
      cerr << "VIDEO ERROR: could not load parameter " << str << " in ParticleManager::LoadEffect()!" << endl; \
    return false; \
  }\
  int32 num_color_components = luaL_getn(L, -1); \
  if(num_color_components != 4)\
  {\
    if(VIDEO_DEBUG) \
      cerr << "VIDEO ERROR: wrong number of components while loading color " << str << " in ParticleManager::LoadEffect()!" << endl; \
    return false; \
  }\
  for(int32 cmp = 1; cmp <= 4; ++cmp) \
  {\
    lua_rawgeti(L, -1, cmp);\
    if(!lua_isnumber(L, -1)) \
    {\
      if(VIDEO_DEBUG) \
        cerr << "VIDEO ERROR: lua_isnumber() returned false while trying to load " << str << " in ParticleManager::LoadEffect()!" << endl; \
      return false; \
    }\
    var[cmp-1] = (float)lua_tonumber(L, -1);\
    lua_pop(L, 1);\
  }\
  lua_pop(L, 1); \
}



namespace hoa_video
{

namespace private_video
{


//-----------------------------------------------------------------------------
// Loads the effect, returns false on failure. This is a temporary function, until
// the GameScript code is finished
//-----------------------------------------------------------------------------

bool TEMP_LoadEffectHelper(const string &filename, lua_State *L, ParticleEffectDef *def)
{
  if(!L)
  {
    if(VIDEO_DEBUG)
      cerr << "VIDEO ERROR: lua_open() failed in ParticleManager::LoadEffect()!" << endl;
    return false;
  }
  
  luaopen_base(L);
  luaopen_io(L);
  luaopen_string(L);
  luaopen_math(L);
  
  if(luaL_loadfile(L, filename.c_str()) || lua_pcall(L, 0, 0, 0))
  {
    cerr << "VIDEO ERROR: could not load particle effect " << filename << " :: " << lua_tostring(L, -1) << endl;        
    return false;
  }

  
  lua_getglobal(L, "systems");
  if(!lua_istable(L, -1))
  {
    if(VIDEO_DEBUG)
      cerr << "VIDEO ERROR: could not find 'systems' in particle effect " << filename << endl;
    return false;
  }

  
  int32 num_systems = luaL_getn(L, -1);
  
  if(num_systems < 1)
  {
    if(VIDEO_DEBUG)
      cerr << "VIDEO ERROR: num_systems less than 1 while opening particle effect " << filename << endl;
    return false;
  }

  for(int32 sys = 1; sys <= num_systems; ++sys)
  {
    // open the table for the sys'th system
    lua_rawgeti(L, -1, sys);
    if(!lua_istable(L, -1))
    {
      if(VIDEO_DEBUG)
        cerr << "VIDEO ERROR: could not find system #" << sys << " in particle effect " << filename << endl;
      return false;
    }
    
    // open up the emitter table
    lua_pushstring(L, "emitter");
    lua_gettable(L, -2);
    if(!lua_istable(L, -1))
    {
      if(VIDEO_DEBUG)
        cerr << "VIDEO ERROR: could not find emitter in system #" << sys << " in particle effect " << filename << endl;
      return false;
    }
    
    ParticleSystemDef *sys_def = new ParticleSystemDef;
    
    LOAD_FLOAT("x", sys_def->emitter._x);
    LOAD_FLOAT("y", sys_def->emitter._y);
    LOAD_FLOAT("x2", sys_def->emitter._x2);
    LOAD_FLOAT("y2", sys_def->emitter._y2);
    LOAD_FLOAT("center_x", sys_def->emitter._center_x);
    LOAD_FLOAT("center_y", sys_def->emitter._center_y);
    LOAD_FLOAT("x_variation", sys_def->emitter._x_variation);
    LOAD_FLOAT("y_variation", sys_def->emitter._y_variation);
    LOAD_FLOAT("radius", sys_def->emitter._radius);
    
    string shape_string;
    LOAD_STRING("shape", shape_string);
    
    if(!strcasecmp(shape_string.c_str(), "point"))
      sys_def->emitter._shape = EMITTER_SHAPE_POINT;
    else if(!strcasecmp(shape_string.c_str(), "line"))
      sys_def->emitter._shape = EMITTER_SHAPE_LINE;
    else if(!strcasecmp(shape_string.c_str(), "circle outline"))
      sys_def->emitter._shape = EMITTER_SHAPE_CIRCLE;
    else if(!strcasecmp(shape_string.c_str(), "circle"))
      sys_def->emitter._shape = EMITTER_SHAPE_FILLED_CIRCLE;
    else if(!strcasecmp(shape_string.c_str(), "rectangle"))
      sys_def->emitter._shape = EMITTER_SHAPE_FILLED_RECTANGLE;
    
    LOAD_BOOL("omnidirectional", sys_def->emitter._omnidirectional);
    LOAD_FLOAT("orientation", sys_def->emitter._orientation);
    LOAD_FLOAT("outer_cone", sys_def->emitter._outer_cone);
    LOAD_FLOAT("inner_cone", sys_def->emitter._inner_cone);
    LOAD_FLOAT("initial_speed", sys_def->emitter._initial_speed);
    LOAD_FLOAT("initial_speed_variation", sys_def->emitter._initial_speed_variation);
    LOAD_FLOAT("emission_rate", sys_def->emitter._emission_rate);
    LOAD_FLOAT("start_time", sys_def->emitter._start_time);
    
    string emitter_mode_string;
    LOAD_STRING("emitter_mode", emitter_mode_string);
    
    if(!strcasecmp(emitter_mode_string.c_str(), "looping"))
      sys_def->emitter._emitter_mode = EMITTER_MODE_LOOPING;
    else if(!strcasecmp(emitter_mode_string.c_str(), "one shot"))
      sys_def->emitter._emitter_mode = EMITTER_MODE_ONE_SHOT;
    else if(!strcasecmp(emitter_mode_string.c_str(), "burst"))
      sys_def->emitter._emitter_mode = EMITTER_MODE_BURST;
    else //.. if(!strcasecmp(emitter_mode_string.c_str(), "always"))
      sys_def->emitter._emitter_mode = EMITTER_MODE_ALWAYS;
    
    string spin_string;
    LOAD_STRING("spin", spin_string);
    
    if(!strcasecmp(spin_string.c_str(), "random"))
      sys_def->emitter._spin = EMITTER_SPIN_RANDOM;
    else if(!strcasecmp(spin_string.c_str(), "counterclockwise"))
      sys_def->emitter._spin = EMITTER_SPIN_COUNTERCLOCKWISE;
    else //..if(!strcasecmp(spin_string.c_str(), "clockwise"))
      sys_def->emitter._spin = EMITTER_SPIN_CLOCKWISE;

    // OK! done loading the emitter data. Now, load the keyframes
    
    lua_pop(L, 1);   // pop the emitter table
    lua_pushstring(L, "keyframes");
    lua_gettable(L, -2);
    
    if(!lua_istable(L, -1))
    {
      if(VIDEO_DEBUG)
        cerr << "VIDEO ERROR: could not locate keyframes while loading particle effect " << filename << endl;
      return false;
    }

    int32 num_keyframes = luaL_getn(L, -1);       
    
    sys_def->keyframes.resize(num_keyframes);
    
    
    for(int32 kf = 0; kf < num_keyframes; ++kf)
    {
      sys_def->keyframes[kf] = new ParticleKeyframe;
      
      // get the kf'th keyframe table
      lua_rawgeti(L, -1, kf+1);
      
      LOAD_FLOAT("size_x", sys_def->keyframes[kf]->size_x);
      LOAD_FLOAT("size_y", sys_def->keyframes[kf]->size_y);
      LOAD_COLOR("color", sys_def->keyframes[kf]->color);
      LOAD_FLOAT("rotation_speed", sys_def->keyframes[kf]->rotation_speed);
      LOAD_FLOAT("size_variation_x", sys_def->keyframes[kf]->size_variation_x);
      LOAD_FLOAT("size_variation_y", sys_def->keyframes[kf]->size_variation_y);
      LOAD_COLOR("color_variation", sys_def->keyframes[kf]->color_variation);
      LOAD_FLOAT("rotation_speed_variation", sys_def->keyframes[kf]->rotation_speed_variation);
      LOAD_FLOAT("time", sys_def->keyframes[kf]->time);
      
      // pop the current keyframe
      lua_pop(L, 1);      
    }
    
    // pop the keyframes table
    lua_pop(L, 1);
    
    lua_pushstring(L, "animation_frames");
    lua_gettable(L, -2);
    
    if(!lua_istable(L, -1))
    {
      if(VIDEO_DEBUG)
        cerr << "VIDEO ERROR: could not locate 'animation_frames' in the effect file " << filename << endl;
      return false;
    }

    int32 num_animation_frames = luaL_getn(L, -1);
    
    if(num_animation_frames < 1)
    {
      if(VIDEO_DEBUG)
        cerr << "VIDEO ERROR: the 'animation_frames' table was empty in effect file " << filename << endl;
      return false;
    }
    
    for(int32 n_frame = 0; n_frame < num_animation_frames; ++n_frame)
    {
      lua_rawgeti(L, -1, n_frame+1);
      
      if(!lua_isstring(L, -1))
      {
        if(VIDEO_DEBUG)
          cerr << "VIDEO ERROR: encountered a non-string element in animation frames array, in effect file " << filename << endl;
        return false;
      }     
      
      string anim_filename = lua_tostring(L, -1);
      sys_def->animation_frame_filenames.push_back(anim_filename);
      
      // pop the current animation frame filename
      lua_pop(L, 1);
    }
    
    // pop the animation_frames table
    lua_pop(L, 1);
    
    lua_pushstring(L, "animation_frame_times");
    lua_gettable(L, -2);
    
    if(!lua_istable(L, -1))
    {
      if(VIDEO_DEBUG)
        cerr << "VIDEO ERROR: could not locate 'animation_frame_times' in the effect file " << filename << endl;
      return false;
    }

    int32 num_animation_frame_times = luaL_getn(L, -1);
    
    if(num_animation_frame_times < 1)
    {
      if(VIDEO_DEBUG)
        cerr << "VIDEO ERROR: the 'animation_frame_times' table was empty in effect file " << filename << endl;
      return false;
    }
    
    for(int32 n_frame_time = 0; n_frame_time < num_animation_frame_times; ++n_frame_time)
    {
      lua_rawgeti(L, -1, n_frame_time+1);
      
      if(!lua_isnumber(L, -1))
      {
        if(VIDEO_DEBUG)
          cerr << "VIDEO ERROR: encountered a non-numeric element in animation frame times array, in effect file " << filename << endl;
        return false;
      }     
      
      int32 anim_frame_time = (int32)lua_tonumber(L, -1);
      sys_def->animation_frame_times.push_back(anim_frame_time);
      
      // pop the current animation frame time
      lua_pop(L, 1);
    }
    
    // pop the animation_frame times table
    lua_pop(L, 1);
    
    LOAD_BOOL("enabled", sys_def->enabled);
    LOAD_INT ("blend_mode", sys_def->blend_mode);
    LOAD_FLOAT("system_lifetime", sys_def->system_lifetime);

    LOAD_FLOAT("particle_lifetime", sys_def->particle_lifetime);
    LOAD_FLOAT("particle_lifetime_variation", sys_def->particle_lifetime_variation);
    LOAD_INT  ("max_particles", sys_def->max_particles);    
    LOAD_FLOAT("damping", sys_def->damping);
    LOAD_FLOAT("damping_variation", sys_def->damping_variation);
    LOAD_FLOAT("acceleration_x", sys_def->acceleration_x);
    LOAD_FLOAT("acceleration_y", sys_def->acceleration_y);
    LOAD_FLOAT("acceleration_variation_x", sys_def->acceleration_variation_x);
    LOAD_FLOAT("acceleration_variation_y", sys_def->acceleration_variation_y);
    LOAD_FLOAT("wind_velocity_x", sys_def->wind_velocity_x);
    LOAD_FLOAT("wind_velocity_y", sys_def->wind_velocity_y);
    LOAD_FLOAT("wind_velocity_variation_x", sys_def->wind_velocity_variation_x);
    LOAD_FLOAT("wind_velocity_variation_y", sys_def->wind_velocity_variation_y);
    LOAD_BOOL ("wave_motion_used", sys_def->wave_motion_used);
    LOAD_FLOAT("wave_length", sys_def->wave_length);
    LOAD_FLOAT("wave_length_variation", sys_def->wave_length_variation);
    LOAD_FLOAT("wave_amplitude", sys_def->wave_amplitude);
    LOAD_FLOAT("wave_amplitude_variation", sys_def->wave_amplitude_variation);
    LOAD_FLOAT("tangential_acceleration", sys_def->tangential_acceleration);
    LOAD_FLOAT("tangential_acceleration_variation", sys_def->tangential_acceleration_variation);
    LOAD_FLOAT("radial_acceleration", sys_def->radial_acceleration);
    LOAD_FLOAT("radial_acceleration_variation", sys_def->radial_acceleration_variation);
    LOAD_BOOL ("user_defined_attractor", sys_def->user_defined_attractor);
    LOAD_FLOAT("attractor_falloff", sys_def->attractor_falloff);
    LOAD_BOOL ("rotation_used", sys_def->rotation_used);
    LOAD_BOOL ("rotate_to_velocity", sys_def->rotate_to_velocity);
    LOAD_BOOL ("speed_scale_used", sys_def->speed_scale_used);
    LOAD_FLOAT("speed_scale", sys_def->speed_scale);
    LOAD_FLOAT("min_speed_scale", sys_def->min_speed_scale);    
    LOAD_FLOAT("max_speed_scale", sys_def->max_speed_scale);
    LOAD_BOOL ("smooth_animation", sys_def->smooth_animation);
    LOAD_BOOL ("modify_stencil", sys_def->modify_stencil);
    
    string stencil_op_string;
    LOAD_STRING("stencil_op", stencil_op_string);   
    
    if(!strcasecmp(stencil_op_string.c_str(), "incr"))
      sys_def->stencil_op = VIDEO_STENCIL_OP_INCREASE;
    else if(!strcasecmp(stencil_op_string.c_str(), "decr"))
      sys_def->stencil_op = VIDEO_STENCIL_OP_DECREASE;
    else if(!strcasecmp(stencil_op_string.c_str(), "zero"))
      sys_def->stencil_op = VIDEO_STENCIL_OP_ZERO;
    else //..if(!strcasecmp(stencil_op_string.c_str(), "one"))
      sys_def->stencil_op = VIDEO_STENCIL_OP_ONE;
    
    LOAD_BOOL("use_stencil", sys_def->use_stencil);
    LOAD_FLOAT("scene_lighting", sys_def->scene_lighting);
    LOAD_BOOL ("random_initial_angle", sys_def->random_initial_angle);

    // pop the system table
    lua_pop(L, 1);
    
    def->_systems.push_back(sys_def);   
  }

  return true;
}


//-----------------------------------------------------------------------------
// LoadEffect: loads an effect definition from disk given the filename
//             Returns NULL if there is a problem with loading
//-----------------------------------------------------------------------------

ParticleEffectDef *ParticleManager::LoadEffect(const std::string &filename)
{
  ParticleEffectDef *def = new ParticleEffectDef;
  lua_State *L = lua_open();

  bool could_load = TEMP_LoadEffectHelper(filename, L, def);  

  if(!could_load)
  {
    lua_close(L);
    delete def;
    return NULL;
  }
  
  return def;
}


//-----------------------------------------------------------------------------
// AddEffect: adds a new particle effect to the list
//-----------------------------------------------------------------------------

ParticleEffectID ParticleManager::AddEffect(const ParticleEffectDef *def, float x, float y)
{
  if(!def)
  {
    if(VIDEO_DEBUG)
      cerr << "VIDEO ERROR: ParticleManager::AddEffect() failed because def was NULL!" << endl;
    return VIDEO_INVALID_EFFECT;
  }
    
  if(def->_systems.empty())
  {
    if(VIDEO_DEBUG)
      cerr << "VIDEO ERROR: ParticleManager::AddEffect() failed because def->_systems was empty!" << endl;
    return VIDEO_INVALID_EFFECT;
  }
  
  ParticleEffect *effect = _CreateEffect(def);
  if(!effect)
  {
    if(VIDEO_DEBUG)
      cerr << "VIDEO ERROR: could not create particle effect in ParticleManager::AddEffect()!" << endl;
    return VIDEO_INVALID_EFFECT;
  }
  
  effect->Move(x, y); 
  _effects[_current_id] = effect;
  
  ++_current_id;
  
  return _current_id - 1;
};


//-----------------------------------------------------------------------------
// Draw: draws all particle effects
//-----------------------------------------------------------------------------

bool ParticleManager::Draw()
{
  VideoManager->PushState();
  VideoManager->SetCoordSys(CoordSys(0.0f, 1024.0f, 768.0f, 0.0f));
  VideoManager->EnableScissoring(false);  
  
  map<ParticleEffectID, ParticleEffect *>::iterator iEffect = _effects.begin();

  glClearStencil(0);
  glClear(GL_STENCIL_BUFFER_BIT);
  
  bool success = true;
  
  while(iEffect != _effects.end())
  {
    if(!(iEffect->second)->_Draw())
    {
      success = false;
      if(VIDEO_DEBUG)
        cerr << "VIDEO ERROR: effect failed to draw in ParticleManager::Draw()!" << endl;
    }
    ++iEffect;
  }
  
  VideoManager->PopState();
  return success;
}


//-----------------------------------------------------------------------------
// Update: updates all particle effects
//-----------------------------------------------------------------------------

bool ParticleManager::Update(int32 frame_time)
{
  float frame_time_seconds = static_cast<float>(frame_time) / 1000.0f;
  
  map<ParticleEffectID, ParticleEffect *>::iterator iEffect = _effects.begin();
  
  bool success = true;
  
  _num_particles = 0;
  
  while(iEffect != _effects.end())
  {
    if(!(iEffect->second)->IsAlive())
    {
      (iEffect->second)->_Destroy();
      
      map<ParticleEffectID, ParticleEffect *>::iterator iEffectNext = iEffect;
      ++iEffectNext;
          
      _effects.erase(iEffect);
      iEffect = iEffectNext;
    }
    else
    {
      if(!(iEffect->second)->_Update(frame_time_seconds))
      {
        success = false;
        if(VIDEO_DEBUG)
          cerr << "VIDEO ERROR: effect failed to update in ParticleManager::Update()!" << endl;
      }
      
      _num_particles += iEffect->second->GetNumParticles();
      ++iEffect;
    }
  }
  
  return success;
}


//-----------------------------------------------------------------------------
// StopAll: stops all particle effects
//-----------------------------------------------------------------------------

void ParticleManager::StopAll(bool kill_immediate)
{
  map<ParticleEffectID, ParticleEffect *>::iterator iEffect = _effects.begin();
  
  while(iEffect != _effects.end())
  {
    (iEffect->second)->Stop(kill_immediate);
  }
}


//-----------------------------------------------------------------------------
// Destroy: destroys all particle effects
//-----------------------------------------------------------------------------

void ParticleManager::Destroy()
{
  map<ParticleEffectID, ParticleEffect *>::iterator iEffect = _effects.begin();
  
  while(iEffect != _effects.end())
  {
    (iEffect->second)->_Destroy();
    delete (iEffect->second);
    ++iEffect;
  }
  
  _effects.clear();
}


//-----------------------------------------------------------------------------
// GetEffect: returns a pointer to the effect with the given ID. Only valid
//            up until the next call to ParticleManager::Update(). In other words,
//            don't store any pointers yourself, store the ID and call GetEffect()
//
//            Returns NULL if the effect cannot be found (perhaps it died)
//-----------------------------------------------------------------------------

ParticleEffect *ParticleManager::GetEffect(ParticleEffectID id)
{
  map<ParticleEffectID, ParticleEffect *>::iterator iEffect = _effects.find(id);
  if(iEffect == _effects.end())
    return NULL;
  else
    return iEffect->second;
}


//-----------------------------------------------------------------------------
// GetNumParticles: returns the entire number of live particles between all
//                  currently displaying effects
//-----------------------------------------------------------------------------

int32 ParticleManager::GetNumParticles()
{
  return _num_particles;
}


//-----------------------------------------------------------------------------
// _CreateEffect: helper to AddEffect(), does the job of initializing a new effect
//                given its definition. Returns NULL on failure
//
//                NOTE: assumes that def isn't NULL and def->_systems is non-empty
//-----------------------------------------------------------------------------

ParticleEffect *ParticleManager::_CreateEffect(const ParticleEffectDef *def)
{
  list<ParticleSystemDef *>::const_iterator iSystem = def->_systems.begin();
  list<ParticleSystemDef *>::const_iterator iEnd = def->_systems.end();
  
  ParticleEffect *effect = new ParticleEffect;
  
  
  // store pointer of effect properties
  
  effect->_effect_def = def;
  
  
  // initialize systems
  
  while(iSystem != iEnd)
  {
    if((*iSystem)->enabled)
    {
      ParticleSystem *sys = new ParticleSystem;
      if(!sys->Create(*iSystem))
      {
        // if a system could not be created then we bail out
        sys->Destroy();
        delete sys;
        
        list<ParticleSystem *>::iterator iEffectSystem = effect->_systems.begin();
        list<ParticleSystem *>::iterator iEffectEnd = effect->_systems.end();
        
        while(iEffectSystem != iEffectEnd)
        {
          (*iEffectSystem)->Destroy();
          delete (*iEffectSystem);
          ++iEffectSystem;
        }
        
        if(VIDEO_DEBUG)
          cerr << "VIDEO ERROR: sys->Create() returned false while trying to create effect!" << endl;
        return NULL;
        
      }
      effect->_systems.push_back(sys);
    }
    ++iSystem;
  }
  
  effect->_alive = true;
  effect->_age = 0.0f;
  return effect;
}


}  // namespace private_video
}  // namespace hoa_video

---