vee_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 VEE_OBJECT_H
#define VEE_OBJECT_H

#include <vee_config.h> 
#include <vee_has_values.h> 
#include <vee_has_variables.h> 

#include <sys/types.h> 

class VEE_RenderClass;
class VEE_Renderer;
class VEE_SceneBox;

enum VEE_ForceType {
  VEE_FORCE_GRAVITY,
  VEE_FORCE_DRAG,
  VEE_FORCE_HIDDEN,
  VEE_FORCE_SIZEOF
};

enum VEE_ObjectType {
  VEE_OBJECT_UNKNOWN,
  VEE_OBJECT_PARTICLE,
  VEE_OBJECT_RIGID_PARTICLE,
  VEE_OBJECT_TAIL_PARTICLE,
  VEE_OBJECT_CURVE_PARTICLE,
  VEE_OBJECT_FORCE,
  VEE_OBJECT_POLYGON,
  VEE_OBJECT_SOURCE,
  VEE_OBJECT_SIZEOF
};

class VEE_ParticleVisualInfo
{
public:

  VEE_ParticleVisualInfo() 
    : m_color(VEE_Rgba::White), m_texture(-1), m_size(0.0), 
      m_rotationRadians(0.0), m_omega(0.0), m_renderClass(0)
  { m_location.clear(); m_velocity.clear(); }

  VEE_ParticleVisualInfo(const VEE_Vector3 &location,  
       const VEE_Vector3 &velocity)
    : m_color(VEE_Rgba::White), m_location(location), m_velocity(velocity),
      m_texture(-1), m_size(0.0), 
      m_rotationRadians(0.0), m_omega(0.0), m_renderClass(0) {}

  ~VEE_ParticleVisualInfo() {}
  
  const VEE_Rgba & color() const { return m_color; }
  void setColor(const VEE_Rgba & c) { m_color = c; }

  VEE_Vector3 & location() { return m_location; }
  const VEE_Vector3 & location() const { return m_location; }
  VEE_Vector3 & velocity() { return m_velocity; }
  const VEE_Vector3 & velocity() const { return m_velocity; }

  void setLocation(const VEE_Vector3 &l) { m_location = l; }
  void setVelocity(const VEE_Vector3 &v) { m_velocity = v; }
  void setLocation3(float x, float y, float z) { m_location.make(x, y, z); }
  void setVelocity3(float x, float y, float z) { m_velocity.make(x, y, z); }

  int  texture() const { return m_texture; }
  void setTexture(int id) { m_texture = id; }

  float size() const { return m_size; }
  void setSize(float s) { m_size = s; }

  float rotation() const { return m_rotationRadians; }
  void setRotation(float radians) { m_rotationRadians = radians; }

  float omega() const { return m_omega; }
  void setOmega(float omega) { m_omega = omega; }

  void setRenderClass(VEE_RenderClass *renderClass) 
  { m_renderClass = renderClass; }
  VEE_RenderClass *renderClass() { return m_renderClass; }

protected:

  VEE_Rgba m_color;
  VEE_Vector3 m_location;
  VEE_Vector3 m_velocity;
  int         m_texture;
  float       m_size;
  float       m_rotationRadians;
  float       m_omega;
  VEE_RenderClass *m_renderClass;
};


class VEE_Object : public VEE_HasValues, 
       public VEE_HasVariables,
       public VEE_ParticleVisualInfo
{
public:
#ifdef VEE_FAST
  void addCheckCount() {}
  void subCheckCount() {}
#else
  void addCheckCount() { m_count++; }  
  void subCheckCount() { m_count--; }  
  static long count() { return m_count; }
#endif

  VEE_Object();
  VEE_Object(VEE_SceneBox *box);
  VEE_Object(const VEE_Object &);
  VEE_Object(const VEE_Vector3 &location,  
       const VEE_Vector3 &velocity, 
       float ageLimit = 1e+10);
  VEE_Object(const VEE_Vector3 &location,  
       float ageLimit = 1e+10);

  virtual ~VEE_Object() {subCheckCount();}

  virtual VEE_Object * clone() const = 0;
  
  virtual bool setValue(const char *, VEE_Value *);
  virtual VEE_Variable getVariable(const char *) const;

  VEE_SceneBox *sceneBox() { return m_sceneBox; }
  void setSceneBox(VEE_SceneBox *b) { m_sceneBox = b; }

  // virtual VEE_Vector3 *centralLocation() { return &m_location; }
  virtual void update(float);
  virtual void updateVelocity(float);
  virtual void collision(const VEE_Vector3 &);

  void setVelocityUpdate(bool p) { m_updateVelocity = p; }

  float age() { return m_age; }
  void setAge(float age) { m_age = age; }

  float ageLimit() { return m_ageLimit; }
  void setAgeLimit(float ageLimit) { m_ageLimit = ageLimit; }

  void setMass(float m) { m_mass = m; }
  void setArea(float a) { m_area = a; }
  float mass() const { return m_mass; }
  float area() const { return m_area; }

  virtual void render(VEE_Renderer *) = 0;

  bool done() const { return m_done; }
  void setDone(bool done) { m_done = done; }

  const char * className() const;

  int objectType() const { return m_objectType; }

protected:
  VEE_SceneBox *m_sceneBox;
  // VEE_Vector3 m_location, m_velocity;
  bool  m_updateVelocity;
  float m_age;
  float m_ageLimit;

  float m_mass;
  float m_area;

  int   m_objectType;

  bool m_done;

#ifndef VEE_FAST
  static long m_count;
#endif
};

#endif

---