src/object/particlesystem.hpp

   1 //  SuperTux
   2 //  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
   3 //
   4 //  This program is free software: you can redistribute it and/or modify
   5 //  it under the terms of the GNU General Public License as published by
   6 //  the Free Software Foundation, either version 3 of the License, or
   7 //  (at your option) any later version.
   8 //
   9 //  This program is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 //  GNU General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU General Public License
  15 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #ifndef HEADER_SUPERTUX_OBJECT_PARTICLESYSTEM_HPP
  18 #define HEADER_SUPERTUX_OBJECT_PARTICLESYSTEM_HPP
  19
  20 #include <vector>
  21
  22 #include "math/vector.hpp"
  23 #include "supertux/game_object.hpp"
  24 #include "util/reader.hpp"
  25
  26 class Surface;
  27
  28 class DisplayManager;
  29
  30 /**
  31  * This is the base class for particle systems. It is responsible for storing a
  32  * set of particles with each having an x- and y-coordinate the number of the
  33  * layer where it should be drawn and a texture.
  34  * The coordinate system used here is a virtual one. It would be a bad idea to
  35  * populate whole levels with particles. So we're using a virtual rectangle
  36  * here that is tiled onto the level when drawing. This rect.has the size
  37  * (virtual_width, virtual_height). We're using modulo on the particle
  38  * coordinates, so when a particle leaves left, it'll reenter at the right
  39  * side.
  40  *
  41  * Classes that implement a particle system should subclass from this class,
  42  * initialize particles in the constructor and move them in the simulate
  43  * function.
  44  */
  45 class ParticleSystem : public GameObject
  46 {
  47 public:
  48   ParticleSystem(float max_particle_size = 60);
  49   virtual ~ParticleSystem();
  50
  51   virtual void draw(DrawingContext& context);
  52
  53 protected:
  54   float max_particle_size;
  55   int z_pos;
  56
  57   class Particle
  58   {
  59   public:
  60     Particle() :
  61       pos(),
  62       texture()
  63     {}
  64
  65     virtual ~Particle()
  66     {}
  67
  68     Vector pos;
  69     Surface* texture;
  70   };
  71
  72   std::vector<Particle*> particles;
  73   float virtual_width, virtual_height;
  74 };
  75
  76 class SnowParticleSystem : public ParticleSystem
  77 {
  78 public:
  79   SnowParticleSystem();
  80   virtual ~SnowParticleSystem();
  81
  82   void parse(const Reader& lisp);
  83
  84   virtual void update(float elapsed_time);
  85
  86   std::string type() const
  87   { return "SnowParticleSystem"; }
  88
  89 private:
  90   class SnowParticle : public Particle
  91   {
  92   public:
  93     float speed;
  94     float wobble;
  95     float anchorx;
  96     float drift_speed;
  97   };
  98
  99   Surface* snowimages[3];
 100
 101 private:
 102   SnowParticleSystem(const SnowParticleSystem&);
 103   SnowParticleSystem& operator=(const SnowParticleSystem&);
 104 };
 105
 106 class GhostParticleSystem : public ParticleSystem
 107 {
 108 public:
 109   GhostParticleSystem();
 110   virtual ~GhostParticleSystem();
 111
 112   void parse(const Reader& lisp);
 113
 114   virtual void update(float elapsed_time);
 115
 116   std::string type() const
 117   { return "GhostParticleSystem"; }
 118
 119 private:
 120   class GhostParticle : public Particle
 121   {
 122   public:
 123     float speed;
 124
 125     GhostParticle() :
 126       speed()
 127     {}
 128   };
 129
 130   Surface* ghosts[2];
 131
 132 private:
 133   GhostParticleSystem(const GhostParticleSystem&);
 134   GhostParticleSystem& operator=(const GhostParticleSystem&);
 135 };
 136
 137 class CloudParticleSystem : public ParticleSystem
 138 {
 139 public:
 140   CloudParticleSystem();
 141   virtual ~CloudParticleSystem();
 142
 143   void parse(const Reader& lisp);
 144
 145   virtual void update(float elapsed_time);
 146
 147   std::string type() const
 148   { return "CloudParticleSystem"; }
 149
 150 private:
 151   class CloudParticle : public Particle
 152   {
 153   public:
 154     float speed;
 155   };
 156
 157   Surface* cloudimage;
 158
 159 private:
 160   CloudParticleSystem(const CloudParticleSystem&);
 161   CloudParticleSystem& operator=(const CloudParticleSystem&);
 162 };
 163
 164 #endif
 165
 166 /* EOF */