vee_variable.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_VARIABLE_H
#define VEE_VARIABLE_H

#include <vee_color.h>
#include <vee_vector3.h>
#include <vee_matrix3.h>

/* Keep in mind that these need to be copied to "vee.i" (scripting
   language wrappers. */
enum VEE_VariableType {
  VEE_VAR_INVALID,
  VEE_VAR_INT,
  VEE_VAR_INT_PTR,
  VEE_VAR_FLOAT,
  VEE_VAR_FLOAT_PTR,
  VEE_VAR_RGBA,
  VEE_VAR_VECTOR3,
  VEE_VAR_VECTOR3_PTR,
  VEE_VAR_MATRIX3,
  VEE_VAR_SIZEOF
};

struct __VEE_VarF { float v[5]; };
// struct __VEE_VarFP { float v; float *vp; };

union __VEE_Variable {

  int          m_int;
  const int   *m_intPtr;
  float        m_float;
  const float *m_floatPtr;
  __VEE_VarF   m_floats;
  const VEE_Vector3  *m_vector3Ptr;
  const VEE_Matrix3  *m_matrix3;
  // void        *m_ptr;  
};

class VEE_Variable
{
public:
  VEE_Variable() : m_type(VEE_VAR_INVALID) {}
  ~VEE_Variable() {}

  // Returns true if the value can be converted to a number
  bool isNumber() const 
  { return m_type >= VEE_VAR_INT && m_type <= VEE_VAR_FLOAT_PTR; }
  
  VEE_VariableType type() const { return m_type; }
  bool isValid() const { return m_type != VEE_VAR_INVALID; }

  inline float getFloat(float def = 0.0) const;
  inline const float * getFloatPtr() const;
  inline int   getInt(int def = 0) const;
  inline const int * getIntPtr() const;

  const VEE_Rgba & getRgba(const VEE_Rgba &def = VEE_Rgba::White)
  { return m_type == VEE_VAR_RGBA ? 
      * (const VEE_Rgba * ) & m_val.m_floats : def; }

  inline const VEE_Vector3 & getVector3(const VEE_Vector3 &def = VEE_Vector3ZERO) const;

  const VEE_Matrix3 & getMatrix3(const VEE_Matrix3 &def = VEE_Matrix3IDENTITY)
  { return m_type == VEE_VAR_MATRIX3 ? *m_val.m_matrix3 : def; }

  void setFloat(float v) { m_type = VEE_VAR_FLOAT; m_val.m_float = v; }
  void setFloatPtr(const float *v) 
  { m_type = VEE_VAR_FLOAT_PTR; m_val.m_floatPtr = v; }
  void setInt(int v)     { m_type = VEE_VAR_INT;   m_val.m_int = v; }
  void setIntPtr(const int *v) 
  { m_type = VEE_VAR_INT_PTR; m_val.m_intPtr = v; }
  void setRgba(const VEE_Rgba &v) 
  { m_type = VEE_VAR_RGBA;   * ((VEE_Rgba *) & m_val.m_floats) = v; }
  void setVector3(const VEE_Vector3 &v) 
  { m_type = VEE_VAR_VECTOR3; * ((VEE_Vector3 *) & m_val.m_floats) = v; }
  void setVector3Ptr(const VEE_Vector3 *v) 
  { m_type = VEE_VAR_VECTOR3_PTR; m_val.m_vector3Ptr = v; }
  void setMatrix3(const VEE_Matrix3 &v) 
  { m_type = VEE_VAR_MATRIX3; m_val.m_matrix3 = &v; }

  VEE_Variable & operator = (float v) { setFloat(v); return *this; }
  VEE_Variable & operator = (const float *v) { setFloatPtr(v); return *this; }
  VEE_Variable & operator = (int v)   { setInt(v); return *this; }
  VEE_Variable & operator = (const int *v) { setIntPtr(v); return *this; }
  VEE_Variable & operator = (const VEE_Vector3 &v) 
    { setVector3(v); return *this; }
  VEE_Variable & operator = (const VEE_Vector3 *v) 
    { setVector3Ptr(v); return *this; }
  VEE_Variable & operator = (const VEE_Rgba &v) 
    { setRgba(v); return *this; }
  VEE_Variable & operator = (const VEE_Matrix3 &v) 
    { setMatrix3(v); return *this; }

protected:
  VEE_VariableType m_type;
  __VEE_Variable m_val;
};

inline float VEE_Variable::getFloat(float def) const
{ 
  if(m_type == VEE_VAR_FLOAT) 
    return m_val.m_float;
  else if(m_type == VEE_VAR_FLOAT_PTR)
    return * m_val.m_floatPtr;
  else if(m_type == VEE_VAR_INT) 
    return m_val.m_int;
  else if(m_type == VEE_VAR_INT_PTR) 
    return * m_val.m_intPtr;
  return def;
}

inline const float * VEE_Variable::getFloatPtr() const
{
  if(m_type == VEE_VAR_FLOAT_PTR)
    return m_val.m_floatPtr;
  return 0;
}

inline int VEE_Variable::getInt(int def) const
{ 
  if(m_type == VEE_VAR_INT) 
    return m_val.m_int;
  else if(m_type == VEE_VAR_INT_PTR) 
    return * m_val.m_intPtr;
  else if(m_type == VEE_VAR_FLOAT) 
    return (int) m_val.m_float;
  else if(m_type == VEE_VAR_FLOAT_PTR)
    return (int) * m_val.m_floatPtr;
  return def;
}

inline const int * VEE_Variable::getIntPtr() const
{
  if(m_type == VEE_VAR_INT_PTR)
    return m_val.m_intPtr;
  return 0;
}

inline const VEE_Vector3 & VEE_Variable::getVector3(const VEE_Vector3 &def) const
{ 
  if(m_type == VEE_VAR_VECTOR3)
    return * (const VEE_Vector3 *) & m_val.m_floats;
  else if(m_type == VEE_VAR_VECTOR3_PTR)
    return * m_val.m_vector3Ptr;
  return def; 
}


#endif

---