SnowParticleSystem Class Reference

#include <snow_particle_system.hpp>

Inherits ParticleSystem.

List of all members.

Public Member Functions
	SnowParticleSystem ()
virtual	~SnowParticleSystem ()
void	parse (const Reader &lisp)
virtual void	update (float elapsed_time)
	This function is called once per frame and allows the object to update it's state.
std::string	type () const
Private Types
enum	State {   ATTACKING, DECAYING, SUSTAINING, RELEASING,   RESTING, MAX_STATE }
Private Member Functions
	SnowParticleSystem (const SnowParticleSystem &)
SnowParticleSystem &	operator= (const SnowParticleSystem &)
Private Attributes
State	state
Timer	timer
float	gust_onset
float	gust_current_velocity
SurfacePtr	snowimages [3]
Classes
class	SnowParticle

---

Detailed Description

Definition at line 23 of file snow_particle_system.hpp.

---

Member Enumeration Documentation

enum SnowParticleSystem::State [private]

Enumerator:

ATTACKING
DECAYING
SUSTAINING
RELEASING
RESTING
MAX_STATE

Definition at line 64 of file snow_particle_system.hpp.

             {
    ATTACKING,
    DECAYING,
    SUSTAINING,
    RELEASING,
    RESTING,
    MAX_STATE
  };

---

Constructor & Destructor Documentation

SnowParticleSystem::SnowParticleSystem

(

)

Definition at line 36 of file snow_particle_system.cpp.

References Surface::create(), graphicsRandom, ParticleSystem::particles, RandomGenerator::rand(), RandomGenerator::randf(), SCREEN_HEIGHT, SCREEN_WIDTH, snowimages, SNOW::SPIN_SPEED, Timer::start(), timer, and ParticleSystem::virtual_width.

                                       :
  state(RELEASING),
  timer(),
  gust_onset(0),
  gust_current_velocity(0)
{
  snowimages[0] = Surface::create("images/objects/particles/snow2.png");
  snowimages[1] = Surface::create("images/objects/particles/snow1.png");
  snowimages[2] = Surface::create("images/objects/particles/snow0.png");

  virtual_width = SCREEN_WIDTH * 2;

  timer.start(.01);

  // create some random snowflakes
  size_t snowflakecount = size_t(virtual_width/10.0);
  for(size_t i=0; i<snowflakecount; ++i) {
    SnowParticle* particle = new SnowParticle;
    int snowsize = graphicsRandom.rand(3);

    particle->pos.x = graphicsRandom.randf(virtual_width);
    particle->pos.y = graphicsRandom.randf(SCREEN_HEIGHT);
    particle->anchorx = particle->pos.x + (graphicsRandom.randf(-0.5, 0.5) * 16);
    // drift will change with wind gusts
    particle->drift_speed = graphicsRandom.randf(-0.5, 0.5) * 0.3;
    particle->wobble = 0.0;

    particle->texture = snowimages[snowsize];
    particle->flake_size = powf(snowsize+3,4); // since it ranges from 0 to 2

    particle->speed = 2 * (1 + (2 - snowsize)/2 + graphicsRandom.randf(1.8)) * 10; // gravity

    // Spinning
    particle->angle = graphicsRandom.randf(360.0);
    particle->spin_speed = graphicsRandom.randf(-SNOW::SPIN_SPEED,SNOW::SPIN_SPEED);

    particles.push_back(particle);
  }
}

SnowParticleSystem::~SnowParticleSystem

(

)

[virtual]

Definition at line 82 of file snow_particle_system.cpp.

{
}

SnowParticleSystem::SnowParticleSystem

(

const SnowParticleSystem &

)

[private]

---

Member Function Documentation

void SnowParticleSystem::parse

(

const Reader &

lisp

)

Definition at line 77 of file snow_particle_system.cpp.

References LAYER_BACKGROUND1, reader_get_layer(), and ParticleSystem::z_pos.

Referenced by Sector::parse_object().

{
  z_pos = reader_get_layer (reader, /* default = */ LAYER_BACKGROUND1);
}

void SnowParticleSystem::update

(

float

elapsed_time

)

[virtual]

This function is called once per frame and allows the object to update it's state.

The elapsed_time is the time since the last frame in seconds and should be the base for all timed calculations (don't use SDL_GetTicks directly as this will fail in pause mode)

Implements GameObject.

Definition at line 86 of file snow_particle_system.cpp.

References ATTACKING, Timer::check(), SNOW::DECAY_RATIO, DECAYING, SNOW::EPSILON, Timer::get_timeleft(), graphicsRandom, gust_current_velocity, gust_onset, MAX_STATE, ParticleSystem::particles, RandomGenerator::randf(), RELEASING, RESTING, Timer::start(), state, SNOW::STATE_LENGTH, SUSTAINING, timer, SNOW::WIND_SPEED, SNOW::WOBBLE_DECAY, and SNOW::WOBBLE_FACTOR.

{
  // Simple ADSR wind gusts

  if (timer.check()) {
    // Change state
    state = (State) ((state + 1) % MAX_STATE);

    if(state == RESTING) {
      // stop wind
      gust_current_velocity = 0;
      // new wind strength
      gust_onset   = graphicsRandom.randf(-SNOW::WIND_SPEED, SNOW::WIND_SPEED);
    }
    timer.start(graphicsRandom.randf(SNOW::STATE_LENGTH));
  }

  // Update velocities
  switch(state) {
    case ATTACKING:
      gust_current_velocity += gust_onset * elapsed_time;
      break;
    case DECAYING:
      gust_current_velocity -= gust_onset * elapsed_time * SNOW::DECAY_RATIO;
      break;
    case RELEASING:
      // uses current time/velocity instead of constants
      gust_current_velocity -= gust_current_velocity * elapsed_time / timer.get_timeleft();
      break;
    case SUSTAINING:
    case RESTING:
      //do nothing
      break;
    default:
      assert(false);
  }

  std::vector<Particle*>::iterator i;

  for(i = particles.begin(); i != particles.end(); ++i) {
    SnowParticle* particle = (SnowParticle*) *i;
    float anchor_delta;

    // Falling
    particle->pos.y += particle->speed * elapsed_time;
    // Drifting (speed approaches wind at a rate dependent on flake size)
    particle->drift_speed += (gust_current_velocity - particle->drift_speed) / particle->flake_size + graphicsRandom.randf(-SNOW::EPSILON,SNOW::EPSILON);
    particle->anchorx += particle->drift_speed * elapsed_time;
    // Wobbling (particle approaches anchorx)
    particle->pos.x += particle->wobble * elapsed_time;
    anchor_delta = (particle->anchorx - particle->pos.x);
    particle->wobble += (SNOW::WOBBLE_FACTOR * anchor_delta) + graphicsRandom.randf(-SNOW::EPSILON, SNOW::EPSILON);
    particle->wobble *= SNOW::WOBBLE_DECAY;
    // Spinning
    particle->angle += particle->spin_speed * elapsed_time;
    particle->angle = fmodf(particle->angle, 360.0);
  }
}

std::string SnowParticleSystem::type

(

)

const [inline]

Definition at line 33 of file snow_particle_system.hpp.

  { return "SnowParticleSystem"; }

SnowParticleSystem& SnowParticleSystem::operator=

(

const SnowParticleSystem &

)

[private]

---

Member Data Documentation

State SnowParticleSystem::state [private]

Definition at line 72 of file snow_particle_system.hpp.

Referenced by update().

Timer SnowParticleSystem::timer [private]

Definition at line 76 of file snow_particle_system.hpp.

Referenced by SnowParticleSystem(), and update().

float SnowParticleSystem::gust_onset [private]

Definition at line 79 of file snow_particle_system.hpp.

Referenced by update().

float SnowParticleSystem::gust_current_velocity [private]

Definition at line 79 of file snow_particle_system.hpp.

Referenced by update().

SurfacePtr SnowParticleSystem::snowimages[3] [private]

Definition at line 83 of file snow_particle_system.hpp.

Referenced by SnowParticleSystem().

---

The documentation for this class was generated from the following files:

• src/object/snow_particle_system.hpp
• src/object/snow_particle_system.cpp

---