|
/* (c) 1999-2000 Tino Schwarze, see COPYING for details */
/**@pkg math*/
/**
* class for a 3D vertex
*
* #include "cVertex.hh"
*
* This class provides a 3D vertex and several operations on it.
* (e.g. adding, scaling, dot product)
*
* @see cMatrix
* @see cQuaternion
*/
#ifndef cVertex_hh
#define cVertex_hh
// PROJECT INCLUDES
#include "common.hh"
/**
* A class for easy matrix math.
*
* Always remember: This class might be used a lot and during time-critical
* operations. Thus, it's optimized for speed, which has the
* consequence that it cannot be derived from this class.
*/
class cVertex
{
public:
// LIFECYCLE
/**
* default constructor (initializes to zero)
*/
cVertex ()
{
ENTER_METHOD("cVertex::cVertex()");
SetZero ();
};
// copy construktor is provided by compiler
/**
* constructor accepting a vertex split into it's components
* @param vx n.x component
* @param vy n.y component
* @param vz n.z component
*/
cVertex (GLfloat vx, GLfloat vy, GLfloat vz)
{
ENTER_METHOD("cVertex::cVertex (vx,vy,vz)");
n.x = vx; n.y = vy; n.z = vz;
} ;
// destructor is provided by compiler
#if DEBUG
/**
* destructor (for debugging purposes only)
*/
~cVertex ()
{
ENTER_METHOD("cVertex::~cVertex()");
}
#endif
// OPERATORS
/**
* operator for scaling by a given value
* @param s scale factor
*/
inline cVertex &operator *= (const GLfloat s)
{
n.x *= s; n.y *= s; n.z *= s;
return *this;
};
/**
* operator for adding two cVertex objects
* @param v cVertex to add
*/
inline cVertex &operator += (const cVertex &v)
{
n.x += v.n.x; n.y += v.n.y; n.z += v.n.z;
return *this;
};
/**
* operator for subtracting two cVertex objects
* @param v cVertex to subtract
*/
inline cVertex &operator -= (const cVertex &v)
{
n.x -= v.n.x; n.y -= v.n.y; n.z -= v.n.z;
return *this;
};
/**
* operator for multiplying any cVertex with a scalar
* @param s value to scale by
*/
inline cVertex operator * (const GLfloat s) const
{
return cVertex (s*n.x, s*n.y, s*n.z);
};
/**
* operator to add two cVertex objects
* @param v cVertex object to add
*/
inline cVertex operator + (const cVertex &v) const
{
return cVertex(n.x+v.n.x, n.y+v.n.y, n.z+v.n.z);
};
/**
* operator for subtracting two cVertex objects
* @param v cVertex object to substract
*/
inline cVertex operator - (const cVertex &v) const
{
return cVertex(n.x-v.n.x, n.y-v.n.y, n.z-v.n.z);
};
/**
* operator to multiply two cVertex objects (dot product)
* @param v cVertex to calculate dot product with
*
* @return dot product of the two cVertex's
*/
inline GLfloat operator * (const cVertex &v) const // dot product
{
return (n.x*v.n.x + n.y*v.n.y + n.z*v.n.z);
}
/**
* operator to retrieve a component of an cVertex by index
* @param idx index of value (0 = x, 1 = y, 2 = z)
*/
inline GLfloat &operator[] (const int idx)
{
return a[idx];
}
/**
* converting to GLfloat *
*/
inline operator GLfloat *()
{
return (GLfloat *)&a;
}
// OPERATIONS
/**
* assign a new value to all three components (it's basically
* superfluous)
* @param vx n.x component
* @param vy n.y component
* @param vz n.z component
*/
inline cVertex Assign (GLfloat vx, GLfloat vy, GLfloat vz)
{
n.x = vx; n.y = vy; n.z = vz;
return *this;
};
/**
* normalize the vertex (make it length 1)
* @return reference to normalized cVertex
*/
inline cVertex &Normalize ()
{
const GLfloat l = GetLength ();
if (l == 0) return *this; // it's zero anyway, so don't touch it
// first calc 1/l
const GLfloat one_by_l = 1.0/l;
// then multiply (should actually save some cycles)
(*this) *= one_by_l;
return *this;
};
/**
* convenience function: translate by given vertex
* @param tx n.x component
* @param ty n.y component
* @param tz n.z component
*/
inline void Translate (GLfloat tx, GLfloat ty, GLfloat tz)
{
n.x += tx; n.y += ty; n.z += tz;
};
/**
* invert direction of vector by inverting all its components
* @returns reference to inverted cVertex
*/
inline cVertex &Invert ()
{
n.x = -n.x; n.y = -n.y; n.z = -n.z;
return *this;
}
/**
* calculate cross product of two given vertices
* @param v1 first vertex
* @param v2 second vertex
*
* @returns cVertex object
*/
inline cVertex CrossProd (const cVertex &v1, const cVertex &v2) const
{
return cVertex (v1.n.y*v2.n.z - v1.n.z*v2.n.y,
v1.n.z*v2.n.x - v1.n.x*v2.n.z,
v1.n.x*v2.n.y - v1.n.y*v2.n.x);
}
/**
* calculate cross product (does not change class)
* @param v vector to calculate cross product with
*
* @returns a cVertex object
*/
inline cVertex CrossProd (const cVertex &v) const
{
return cVertex (n.y*v.n.z - n.z*v.n.y,
n.z*v.n.x - n.x*v.n.z,
n.x*v.n.y - n.y*v.n.x);
}
// ACCESS
/**
* set vertex to zero vector
*/
inline void SetZero () { n.x = n.y = n.z = 0; };
/**
* query current x component of vector
* @returns GLfloat - value of x component
*/
inline GLfloat GetX () const {
return n.x;
}
/**
* query current y component of vector
* @returns GLfloat - value of y component
*/
inline GLfloat GetY () const {
return n.y;
}
/**
* query current z component of vector
* @returns GLfloat - value of z component
*/
inline GLfloat GetZ () const {
return n.z;
}
/**
* determine length of vertex
* @returns length of vertex
*/
inline GLfloat GetLength () const
{
return sqrt (n.x*n.x + n.y*n.y + n.z*n.z);
};
private:
// I was tempted to make this public but I decided against it for the
// sake of a cleander design. Sigh.
/**
* Anonymous union used to store the vector components.
* By using this union, we're able to access the vector by
* component names or component indices.*/
union {
struct {
GLfloat x, y, z;
} n;
GLfloat a[3];
};
};
#endif // ifndef cVertex_hh
/* vim:ts=4:smartindent:
*/
|