gee_particle_object.h

Go to the documentation of this file.

/* -*- C++ -*- */

/* COPYRIGHT
 *
 * This file is part of the Visual Effects Engine - VEE
 *
 * Read the "VEE-LICENSE" file for the license.
 *
 * Authors & Copyright:   
 *
 * Tommi Ilmonen, Tuukka Heikura, Marko Myllymaa and 
 * Janne Kontkanen 2001-2004
 *
 * Additional copyrights: Tekes 2003-2004
 *
 * firstname.lastname@hut.fi
 *
 */

#ifndef GEE_PARTICLE_OBJECT_H
#define GEE_PARTICLE_OBJECT_H

#include <gee_geometry.h>


#include <vee_bounding_box.h>
#include <vee_clonable_pointer.h>
#include <vee_color.h>
#include <vee_object.h>

#include <list>

class GEE_ParticleData
{
public:
  GEE_ParticleData(const VEE_Vector3 & location = VEE_Vector3ZERO,
       const VEE_Vector3 & velocity = VEE_Vector3ZERO,
       const VEE_Rgba    & color = VEE_Rgba::White,
       const std::string & textureName = "",
       float               size = 1.0)
    : m_location(location),
      m_velocity(velocity),
      m_color(color),
      m_textureName(textureName),
      m_texture(-1),
      m_size(size),
      m_rotation(0.0f)
  {}

  void setSize(float s)
  {
    m_size = s;
    if(m_particle.ptr())
      m_particle.ptr()->setSize(s);
  }

  void setRotation(float r)
  {
    m_rotation = r;
    if(m_particle.ptr())
      m_particle.ptr()->setRotation(r);
  }

  void setLocation(const VEE_Vector3 & loc)
  {
    m_location = loc;
    if(m_particle.ptr())
      m_particle.ptr()->setLocation(loc);
  }

  void setVelocity(const VEE_Vector3 & vel)
  {
    m_velocity = vel;
    if(m_particle.ptr())
      m_particle.ptr()->setVelocity(vel);
  }

  void setColor(const VEE_Rgba & c)
  {
    m_color = c;
    if(m_particle.ptr())
      m_particle.ptr()->setColor(c);
  }

  void setTexture(const std::string & texName, int t)
  {
    m_textureName = texName;
    setTexture(t);
  }

  void setTexture(int t)
  {
    m_texture = t;
    if(m_particle.ptr())
      m_particle.ptr()->setTexture(t);
  }

  void setObject(VEE_Object * obj)
  {
    if(obj) {
      obj->setLocation(m_location);
      obj->setVelocity(m_velocity);
      obj->setColor(m_color);
    }
    
    m_particle = obj;
  }

  void setRenderClass(const std::string & className, VEE_RenderClass * rc)
  {
    m_renderClassName = className;
    
    if(m_particle.ptr())
      m_particle.ptr()->setRenderClass(rc);
  }

  bool read(GEE_Io *);
  bool write(GEE_Io *);  

  VEE_Vector3 m_location;
  VEE_Vector3 m_velocity;
  VEE_Rgba    m_color;
  std::string m_textureName;
  int         m_texture;
  float       m_size;
  float       m_rotation;

  std::string m_renderClassName;

  VEE_ClonablePointer<VEE_Object> m_particle;
};


class GEE_ParticleObject : public GEE_Geometry
{
public:

  typedef std::list<GEE_ParticleData>::iterator iterator;

  GEE_ParticleObject();
  virtual ~GEE_ParticleObject();
  
  static GEE_Geometry * create();
  virtual GEE_Geometry * clone() const;
  virtual bool eraseData(GEE_Containment *);  
  virtual bool intersects(GEE_Containment *);
  virtual bool colorData(GEE_ReColor *);
  virtual bool moveData(GEE_Mover *);
  virtual void render(GEE_Renderer *);
  virtual bool getBoundingBox(VEE_BoundingBox *);
  virtual void setMaterial(const GEE_Material &m);

  virtual bool read(GEE_Io *);
  virtual bool write(GEE_Io *);

  GEE_Geometry * removeData(const VEE_Vector3 &loc, float radius);
  void addParticle(const GEE_ParticleData &);

  void retexture(GEE_Containment *, const std::string & texName, int texId);

  iterator begin() { return m_particles.begin(); }
  iterator end()   { return m_particles.end(); }
  uint particleCount() const { return m_particles.size(); }

  static GEE_ParticleData & getParticleData(iterator & it) { return *it; }

protected:

  std::list<GEE_ParticleData> m_particles;
  VEE_BoundingBox             m_bbox;
};

#endif

---