Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals | Related Pages | Search for 

NLMISC::CQuatT< T > Class Template Reference

#include <quat.h>

Detailed Description

template<class T>
class NLMISC::CQuatT< T >

A Template quaternion. Use CQuat and CQuatD.
Author:
Antoine Viau.

Nevrax France

Date:
2000

Definition at line 74 of file quat.h.

Public Member Functions

Basic Quaternions operations.
CQuatT conjugate () const
 return the conjugate of this quaternion.

void invert ()
 Invert this quaternion. If normalized, conjugate is faster and does same thing.

CQuatT inverted () const
 return the quaternion inverted.

CQuatT operator * (const CQuatT &) const
 Quaternion multiplication/composition.

CQuatT & operator *= (const CQuatT &)
 return the conjugate of this quaternion.

Object
 CQuatT (const CAngleAxis &aa)
 ctor of a UNIT quaternion, from an angle axis.

 CQuatT (const CVector &axis, float angle)
 ctor of a UNIT quaternion, from an angle axis.

 CQuatT (T X, T Y, T Z, T W)
 ctor of a UNIT quaternion, from an angle axis.

 CQuatT ()
 ctor of a UNIT quaternion, from an angle axis.

Comparison
bool equal (const CQuatT &a, float epsilon=1E-6f) const
void identity ()
bool isIdentity () const
bool operator== (const CQuatT &a) const
Misc.
CQuatT exp ()
 compute quaternion exponent.

CQuatT log ()
 compute logn quaternion.

void makeClosest (const CQuatT &o)
 ensure that *this and q are on same side of hypersphere, ie dotProduct(*this,q) is >0, modifying this if necessary.

void serial (IStream &f)
 serial.

To/From other orientation.
float getAngle () const
 Return the equivalent angle of this quaternion. (in radian).

CAngleAxis getAngleAxis () const
 Return the equivalent Unit AngleAxis of this quaternion.

CVector getAxis () const
 Return the equivalent Unit axis of this quaternion.

void setAngleAxis (const CAngleAxis &angAxis)
 Build a UNIT quaternion from an AngleAxis.

void setAngleAxis (const CVector &axis, float angle)
 Build a UNIT quaternion from an AngleAxis.

4D vector operations.
T norm () const
 return the norm of the 4D vector.

void normalize ()
 Normalize the quaternion.

CQuatT normed () const
 Return the quaternion normalized.

CQuatT operator * (T f) const
 return the norm of the 4D vector.

CQuatT & operator *= (T f)
 return the norm of the 4D vector.

CQuatT operator+ () const
 return the norm of the 4D vector.

CQuatT operator+ (const CQuatT &o) const
 return the norm of the 4D vector.

CQuatT & operator+= (const CQuatT &o)
 return the norm of the 4D vector.

CQuatT operator- () const
 return the norm of the 4D vector.

CQuatT operator- (const CQuatT &o) const
 return the norm of the 4D vector.

CQuatT & operator-= (const CQuatT &o)
 return the norm of the 4D vector.

CQuatT operator/ (T f) const
 return the norm of the 4D vector.

CQuatT & operator/= (T f)
 return the norm of the 4D vector.

T sqrnorm () const
 return the square of the norm of the 4D vector.

Sets.
void set (T X, T Y, T Z, T W)

Static Public Member Functions

Quaternions static functions.
T dotProduct (const CQuatT< T > &q0, const CQuatT< T > &q1)
 Return the dotProduct of 2 quaternions.

CQuatT lnDif (const CQuatT &q0, const CQuatT &q1)
 compute lnDiff of q0.inverted()*q1.

CQuatT slerp (const CQuatT< T > &q0, const CQuatT< T > &q1, float t)
CQuatT squad (const CQuatT< T > &q0, const CQuatT< T > &tgtQ0, const CQuatT< T > &tgtQ1, const CQuatT< T > &q1, float t)
CQuatT squadrev (const CAngleAxis &rot, const CQuatT< T > &q0, const CQuatT< T > &tgtQ0, const CQuatT< T > &tgtQ1, const CQuatT< T > &q1, float t)

Data Fields

T w
T x
T y
T z

Constructor & Destructor Documentation

template<class T>
NLMISC::CQuatT< T >::CQuatT (   )  [inline]
 

ctor of a UNIT quaternion, from an angle axis.

Definition at line 84 of file quat.h.

Referenced by NLMISC::CQuatT< float >::conjugate(), NLMISC::CQuatT< float >::operator *(), NLMISC::CQuatT< float >::operator+(), NLMISC::CQuatT< float >::operator-(), and NLMISC::CQuatT< float >::operator/(). 

00084 : x((T)0.0),y((T)0.0),z((T)0.0),w((T)1.0) {}

template<class T>
NLMISC::CQuatT< T >::CQuatT (  T  X,
T  Y,
T  Z,
T  W
)  [inline]
 

ctor of a UNIT quaternion, from an angle axis.

Definition at line 85 of file quat.h. 

00085 : x(X), y(Y), z(Z), w(W) {}

template<class T>
NLMISC::CQuatT< T >::CQuatT (  const CVector &  axis,
float  angle
)  [inline]
 

ctor of a UNIT quaternion, from an angle axis.

Definition at line 87 of file quat.h. 

00087 {setAngleAxis(axis, angle);}

template<class T>
NLMISC::CQuatT< T >::CQuatT (  const CAngleAxis &  aa  )  [inline]
 

ctor of a UNIT quaternion, from an angle axis.

Definition at line 89 of file quat.h. 

00089 {setAngleAxis(aa);}

Member Function Documentation

template<class T>
CQuatT NLMISC::CQuatT< T >::conjugate (   )  const [inline]
 

return the conjugate of this quaternion.

Definition at line 139 of file quat.h.

Referenced by NLMISC::CQuatT< T >::invert(). 

00139 {return CQuatT(-x, -y, -z, w);}

template<class T>
T NLMISC::CQuatT< T >::dotProduct (  const CQuatT< T > &  q0,
const CQuatT< T > &  q1
)  [static]
 

Return the dotProduct of 2 quaternions.

Definition at line 309 of file quat.h.

References NLMISC::CQuatT< T >::w, NLMISC::CQuatT< T >::x, NLMISC::CQuatT< T >::y, and NLMISC::CQuatT< T >::z.

Referenced by NLMISC::CQuatT< T >::makeClosest(). 

00310 {
00311         return q0.x*q1.x + q0.y*q1.y + q0.z*q1.z + q0.w*q1.w;
00312 }

template<class T>
bool NLMISC::CQuatT< T >::equal (  const CQuatT< T > &  a,
float  epsilon = 1E-6f
)  const [inline]
 

Definition at line 227 of file quat.h.

References NLMISC::CQuatT< T >::w, w, NLMISC::CQuatT< T >::x, x, NLMISC::CQuatT< T >::y, y, NLMISC::CQuatT< T >::z, and z. 

00228 {
00229         if (fabs(x-a.x)<epsilon &&
00230                 fabs(y-a.y)<epsilon &&
00231                 fabs(z-a.z)<epsilon &&
00232                 fabs(w-a.w)<epsilon )
00233         {
00234                 return true;
00235         }
00236         return false;
00237 }

template<class T>
CQuatT< T > NLMISC::CQuatT< T >::exp (   ) 
 

compute quaternion exponent.

Definition at line 445 of file quat.h.

References len, NLMISC::QuatEpsilon, x, y, and z. 

00446 {
00447         double  len;
00448         len = sqrt (x*x + y*y + z*z);
00449 
00450         if (len < QuatEpsilon)
00451                 return CQuatT<T>(0.f, 0.f, 0.f, 1.f);
00452         else
00453         {
00454                 double len1 = sin(len) / len; 
00455                 return CQuatT<T>( (T)(x*len1), (T)(y*len1), (T)(z*len1), (T)cos(len));
00456         }
00457 }

template<class T>
float NLMISC::CQuatT< T >::getAngle (   )  const [inline]
 

Return the equivalent angle of this quaternion. (in radian).

Definition at line 148 of file quat.h.

Referenced by NLMISC::CQuatT< float >::getAngleAxis(). 

00148 {return (float)(2*acos(w/norm()));}

template<class T>
CAngleAxis NLMISC::CQuatT< T >::getAngleAxis (   )  const [inline]
 

Return the equivalent Unit AngleAxis of this quaternion.

Definition at line 150 of file quat.h. 

00150 {return CAngleAxis(getAxis(), getAngle());}

template<class T>
CVector NLMISC::CQuatT< T >::getAxis (  void   )  const [inline]
 

Return the equivalent Unit axis of this quaternion.

Definition at line 146 of file quat.h.

Referenced by NLMISC::CQuatT< float >::getAngleAxis(). 

00146 {CVector ret((float)x,(float)y,(float)z); return ret.normed();}

template<class T>
void NLMISC::CQuatT< T >::identity (   )  [inline]
 

Definition at line 102 of file quat.h.

Referenced by NLMISC::CQuatT< T >::normalize(). 

00102 {x = y = z = 0.0f ;     w = 1.0f; }

template<class T>
void NLMISC::CQuatT< T >::invert (   )  [inline]
 

Invert this quaternion. If normalized, conjugate is faster and does same thing.

Definition at line 265 of file quat.h.

References NLMISC::CQuatT< T >::conjugate(), and NLMISC::CQuatT< T >::sqrnorm().

Referenced by NLMISC::CQuatT< float >::inverted(). 

00266 {
00267         // Must invert the norm.
00268         T       f= sqrnorm();
00269         if(f!=0)
00270         {
00271                 *this/=f;
00272         }
00273 
00274         *this= conjugate();
00275 }

template<class T>
CQuatT NLMISC::CQuatT< T >::inverted (   )  const [inline]
 

return the quaternion inverted.

Definition at line 137 of file quat.h.

Referenced by NLMISC::CQuatT< T >::lnDif(). 

00137 {CQuatT ret= *this; ret.invert(); return ret;}

template<class T>
bool NLMISC::CQuatT< T >::isIdentity (   )  const [inline]
 

Definition at line 103 of file quat.h. 

00103 {return (x==0.0f && y==0.0f && z==0.0f && w==1.0f);}

template<class T>
CQuatT< T > NLMISC::CQuatT< T >::lnDif (  const CQuatT< T > &  q0,
const CQuatT< T > &  q1
)  [static]
 

compute lnDiff of q0.inverted()*q1.

Definition at line 462 of file quat.h.

References NLMISC::CQuatT< T >::inverted(), NLMISC::CQuatT< T >::log(), and NLMISC::CQuatT< T >::normalize(). 

00463 {
00464         CQuatT<T>       dif = q0.inverted()*q1;
00465         dif.normalize();
00466 
00467         return dif.log();
00468 }

template<class T>
CQuatT< T > NLMISC::CQuatT< T >::log (   ) 
 

compute logn quaternion.

Definition at line 427 of file quat.h.

References len, NLMISC::QuatEpsilon, w, x, y, and z.

Referenced by NLMISC::CQuatT< T >::lnDif(). 

00428 {
00429         double  len;
00430         len = sqrt (x*x + y*y + z*z);
00431 
00432         if (len < QuatEpsilon)
00433                 return CQuatT<T>(0.f, 0.f, 0.f, 0.f);
00434         else
00435         {
00436                 double div = (float) acos (w) / len;
00437                 return CQuatT<T>( (T)(x*div), (T)(y*div), (T)(z*div), 0.f);
00438         }
00439 
00440 }

template<class T>
void NLMISC::CQuatT< T >::makeClosest (  const CQuatT< T > &  o  ) 
 

ensure that *this and q are on same side of hypersphere, ie dotProduct(*this,q) is >0, modifying this if necessary.

Definition at line 473 of file quat.h.

References NLMISC::CQuatT< T >::dotProduct(). 

00474 {
00475         if( dotProduct(*this, o) < 0 )
00476                 *this= -(*this);
00477 }

template<class T>
T NLMISC::CQuatT< T >::norm (   )  const [inline]
 

return the norm of the 4D vector.

Definition at line 121 of file quat.h.

Referenced by NLMISC::CQuatT< float >::getAngle(), and NLMISC::CQuatT< T >::normalize(). 

00121 {return (T)sqrt(sqrnorm());}

template<class T>
void NLMISC::CQuatT< T >::normalize (   )  [inline]
 

Normalize the quaternion.

Definition at line 280 of file quat.h.

References NLMISC::CQuatT< T >::identity(), and NLMISC::CQuatT< T >::norm().

Referenced by NLMISC::CQuatT< T >::lnDif(), and NLMISC::CQuatT< float >::normed(). 

00281 {
00282         T       f= norm();
00283         if(f==0)
00284                 identity();
00285         else
00286         {
00287                 *this/=f;
00288         }
00289 }

template<class T>
CQuatT NLMISC::CQuatT< T >::normed (   )  const [inline]
 

Return the quaternion normalized.

Definition at line 125 of file quat.h. 

00125 {CQuatT ret= *this; ret.normalize(); return ret;}

template<class T>
CQuatT< T > NLMISC::CQuatT< T >::operator * (  const CQuatT< T > &   )  const [inline]
 

Quaternion multiplication/composition.

Definition at line 242 of file quat.h.

References NLMISC::CQuatT< T >::w, w, x, NLMISC::CQuatT< T >::x, NLMISC::CQuatT< T >::y, y, z, and NLMISC::CQuatT< T >::z. 

00243 {
00244         // wres= ww´ - v·v´
00245         // vres= wv´ + w´v + v^v´ ] 
00246         return  CQuatT<T>(
00247                                         (w*o.x) +(x*o.w) + (y*o.z)-(z*o.y),
00248                                         (w*o.y) +(y*o.w) + (z*o.x)-(x*o.z),
00249                                         (w*o.z) +(z*o.w) + (x*o.y)-(y*o.x),
00250                                         (w*o.w)-(x*o.x)-(y*o.y)-(z*o.z) );
00251 
00252 }

template<class T>
CQuatT NLMISC::CQuatT< T >::operator * (  T  f  )  const [inline]
 

return the norm of the 4D vector.

Definition at line 114 of file quat.h. 

00114 {return CQuatT(x*f,y*f,z*f,w*f);}

template<class T>
CQuatT< T > & NLMISC::CQuatT< T >::operator *= (  const CQuatT< T > &   )  [inline]
 

return the conjugate of this quaternion.

Definition at line 256 of file quat.h. 

00257 {
00258         *this= *this * o;
00259         return *this;
00260 }

template<class T>
CQuatT& NLMISC::CQuatT< T >::operator *= (  T  f  )  [inline]
 

return the norm of the 4D vector.

Definition at line 110 of file quat.h. 

00110 {x*=f;y*=f;z*=f;w*=f; return *this;}

template<class T>
CQuatT NLMISC::CQuatT< T >::operator+ (   )  const [inline]
 

return the norm of the 4D vector.

Definition at line 117 of file quat.h. 

00117 {return *this; }

template<class T>
CQuatT NLMISC::CQuatT< T >::operator+ (  const CQuatT< T > &  o  )  const [inline]
 

return the norm of the 4D vector.

Definition at line 112 of file quat.h. 

00112 {return CQuatT(x+o.x,y+o.y,z+o.z,w+o.w);}

template<class T>
CQuatT& NLMISC::CQuatT< T >::operator+= (  const CQuatT< T > &  o  )  [inline]
 

return the norm of the 4D vector.

Definition at line 108 of file quat.h. 

00108 {x+=o.x; y+=o.y; z+=o.z; w+=o.w; return *this;}

template<class T>
CQuatT NLMISC::CQuatT< T >::operator- (   )  const [inline]
 

return the norm of the 4D vector.

Definition at line 116 of file quat.h. 

00116 {return(CQuatT(-x,-y,-z,-w)); }

template<class T>
CQuatT NLMISC::CQuatT< T >::operator- (  const CQuatT< T > &  o  )  const [inline]
 

return the norm of the 4D vector.

Definition at line 113 of file quat.h. 

00113 {return CQuatT(x-o.x,y-o.y,z-o.z,w-o.w);}

template<class T>
CQuatT& NLMISC::CQuatT< T >::operator-= (  const CQuatT< T > &  o  )  [inline]
 

return the norm of the 4D vector.

Definition at line 109 of file quat.h. 

00109 {x-=o.x; y-=o.y; z-=o.z; w-=o.w; return *this;}

template<class T>
CQuatT NLMISC::CQuatT< T >::operator/ (  T  f  )  const [inline]
 

return the norm of the 4D vector.

Definition at line 115 of file quat.h. 

00115 {double oof= 1.0/f; return CQuatT(x*oof,y*oof,z*oof,w*oof);}

template<class T>
CQuatT& NLMISC::CQuatT< T >::operator/= (  T  f  )  [inline]
 

return the norm of the 4D vector.

Definition at line 111 of file quat.h. 

00111 {double oof= 1.0/f; x=(T)(x*oof); y=(T)(y*oof); z= (T)(z*oof); w=(T)(w*oof); return *this;}

template<class T>
bool NLMISC::CQuatT< T >::operator== (  const CQuatT< T > &  a  )  const [inline]
 

Definition at line 100 of file quat.h. 

00100 {return (x==a.x && y==a.y && z==a.z && w==a.w);}

template<class T>
void NLMISC::CQuatT< T >::serial (  IStream &  f  )  [inline]
 

serial.

Definition at line 168 of file quat.h. 

00169         {
00170                 f.serial(x,y,z,w);
00171         }

template<class T>
void NLMISC::CQuatT< T >::set (  T  X,
T  Y,
T  Z,
T  W
)  [inline]
 

Definition at line 95 of file quat.h.

Referenced by NLMISC::CQuatT< T >::squadrev(). 

00095 {x= X; y= Y; z= Z; w= W;}

template<class T>
void NLMISC::CQuatT< T >::setAngleAxis (  const CAngleAxis &  angAxis  )  [inline]
 

Build a UNIT quaternion from an AngleAxis.

Definition at line 155 of file quat.h. 

00155 {setAngleAxis(angAxis.Axis, angAxis.Angle);}

template<class T>
void NLMISC::CQuatT< T >::setAngleAxis (  const CVector &  axis,
float  angle
)  [inline]
 

Build a UNIT quaternion from an AngleAxis.

Definition at line 294 of file quat.h.

References v, w, x, y, and z.

Referenced by NLMISC::CQuatT< float >::CQuatT(), and NLMISC::CQuatT< float >::setAngleAxis(). 

00295 {
00296         CVector         v= axis;
00297         v.normalize();
00298         double  ca= cos(angle/2);
00299         double  sa= sin(angle/2);
00300         x= (T)(v.x*sa);
00301         y= (T)(v.y*sa);
00302         z= (T)(v.z*sa);
00303         w= (T)(ca);
00304 }

template<class T>
CQuatT< T > NLMISC::CQuatT< T >::slerp (  const CQuatT< T > &  q0,
const CQuatT< T > &  q1,
float  t
)  [static]
 

Quaternion spherical linear interpolation. when t==0, ret==q0, when t==1, ret==q1. No hemisphere correction is made.

Definition at line 317 of file quat.h.

References t.

Referenced by NLMISC::CQuatT< T >::squad(). 

00318 {
00319         // omega is the 4D angle between q0 and q1.
00320         double  omega, cosom,sinom;
00321         T       factq0= 1;
00322         T       s0,s1;
00323 
00324         cosom = CQuatT<T>::dotProduct(q0, q1);
00325 
00326         // Make q0 and q1 on the same hemisphere.
00327         /*if(cosom<0)
00328         {
00329                 cosom= -cosom;
00330                 factq0= -1;
00331         }*/
00332         // ????
00333 
00334         if ( cosom < 1.0 - NLMISC::QuatEpsilon)
00335         { 
00336                 omega = acos(cosom);
00337                 sinom = sin(omega);
00338                 s0 = (T) (sin((1.0f - t)*omega) / sinom);
00339                 s1 = (T) (sin(t*omega) / sinom);
00340         }
00341         else
00342         {       // q0 and q1 are nearly the same => sinom nearly 0. We can't slerp.
00343                 // just linear interpolate.
00344                 s0 = (T)(1.0 - t);
00345                 s1 = t;
00346         }
00347 
00348         return  q0*(factq0*s0) + q1*s1;
00349 
00350 }

template<class T>
T NLMISC::CQuatT< T >::sqrnorm (   )  const [inline]
 

return the square of the norm of the 4D vector.

Definition at line 119 of file quat.h.

Referenced by NLMISC::CQuatT< T >::invert(), and NLMISC::CQuatT< float >::norm(). 

00119 {return (x*x + y*y + z*z + w*w);}

template<class T>
CQuatT< T > NLMISC::CQuatT< T >::squad (  const CQuatT< T > &  q0,
const CQuatT< T > &  tgtQ0,
const CQuatT< T > &  tgtQ1,
const CQuatT< T > &  q1,
float  t
)  [static]
 

Quaternion Quadratic spherical linear interpolation. when t==0, ret==q0, when t==1, ret==q1. No hemisphere correction is made.

Definition at line 355 of file quat.h.

References NLMISC::CQuatT< T >::slerp(), and t. 

00356 {
00357         return CQuatT<T>::slerp(
00358                 CQuatT<T>::slerp(q0, q1, t),
00359                 CQuatT<T>::slerp(tgtQ0, tgtQ1, t),
00360                 2.f*(1.f-t)*t);
00361 }

template<class T>
CQuatT< T > NLMISC::CQuatT< T >::squadrev (  const CAngleAxis &  rot,
const CQuatT< T > &  q0,
const CQuatT< T > &  tgtQ0,
const CQuatT< T > &  tgtQ1,
const CQuatT< T > &  q1,
float  t
)  [static]
 

Quaternion Quadratic spherical linear interpolation, with multi revision support.

Definition at line 366 of file quat.h.

References NLMISC::CAngleAxis::Angle, NLMISC::CAngleAxis::Axis, NLMISC::Pi, NLMISC::QuatEpsilon, s, NLMISC::CQuatT< T >::set(), t, v, NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z. 

00367 {
00368         float s,v;
00369         float omega = rot.Angle* 0.5f;
00370         float nrevs = 0.0f;
00371         CQuatT<T>       ret,qaxis,pp,qq;
00372 
00373         // just one rev?
00374         //==============
00375         if (omega<Pi-QuatEpsilon)
00376         {
00377                 ret = CQuatT<T>::squad(q0,tgtQ0,tgtQ1,q1,t);
00378                 return ret; 
00379         }
00380 
00381 
00382         // multirev.
00383         //==============
00384 
00385         // rotation of 180deg around rot.Axis.  (=> sin(a/2)==sin(Pi/2)==1, and c(a/2)=0).
00386         qaxis.set(rot.Axis.x, rot.Axis.y, rot.Axis.z, 0);
00387 
00388         // the number of revisions (float!)
00389         nrevs= (float)(omega/Pi);
00390         // Angle>2Pi. squad from 0 to Pi, slerp from Pi to Angle-Pi, squad from Angle-Pi to Angle.
00391         s = t*2*nrevs;
00392         
00393 
00394         // So for s, squad from 0 to 1, slerp from 1 to 2*nrevs-1, squad from 2*nrevs-1 to 2*nrevs.
00395         if (s < 1.0f)
00396         {
00397                 // first part.
00398                 pp = q0*qaxis;
00399                 ret = CQuatT<T>::squad(q0,tgtQ0,pp,pp,s);
00400         }
00401         else
00402         {
00403                 v = s - (2.0f*nrevs - 1.0f);
00404                 if( v <= 0.0f)
00405                 {
00406                         // middle part
00407                         while (s >= 2.0f) s -= 2.0f;
00408                         pp = q0*qaxis;
00409                         // s vary from 1 to 2. This is still correct for slerp().
00410                         ret = CQuatT<T>::slerp(q0,pp,s);
00411                 }
00412                 else
00413                 {
00414                         // Last part.
00415                         qq = - q1*qaxis;
00416                         ret= CQuatT<T>::squad(qq,qq,tgtQ1,q1,v);
00417                 }
00418         }
00419 
00420         return ret;
00421 }

Field Documentation

template<class T>
T NLMISC::CQuatT< T >::w
 

Definition at line 77 of file quat.h.

Referenced by NLMISC::CQuatT< T >::dotProduct(), NLMISC::CQuatT< T >::equal(), NLMISC::CQuatT< T >::operator *(), NLMISC::CQuatT< float >::operator+(), NLMISC::CQuatT< float >::operator+=(), NLMISC::CQuatT< float >::operator-(), NLMISC::CQuatT< float >::operator-=(), NLMISC::CQuatD::operator=(), NLMISC::CQuat::operator=(), and NLMISC::CQuatT< float >::operator==().

template<class T>
T NLMISC::CQuatT< T >::x
 

Definition at line 77 of file quat.h.

Referenced by NLMISC::CQuatT< T >::dotProduct(), NLMISC::CQuatT< T >::equal(), NLMISC::CQuatT< T >::operator *(), NLMISC::CQuatT< float >::operator+(), NLMISC::CQuatT< float >::operator+=(), NLMISC::CQuatT< float >::operator-(), NLMISC::CQuatT< float >::operator-=(), NLMISC::CQuatD::operator=(), NLMISC::CQuat::operator=(), and NLMISC::CQuatT< float >::operator==().

template<class T>
T NLMISC::CQuatT< T >::y
 

Definition at line 77 of file quat.h.

Referenced by NLMISC::CQuatT< T >::dotProduct(), NLMISC::CQuatT< T >::equal(), NLMISC::CQuatT< T >::operator *(), NLMISC::CQuatT< float >::operator+(), NLMISC::CQuatT< float >::operator+=(), NLMISC::CQuatT< float >::operator-(), NLMISC::CQuatT< float >::operator-=(), NLMISC::CQuatD::operator=(), NLMISC::CQuat::operator=(), and NLMISC::CQuatT< float >::operator==().

template<class T>
T NLMISC::CQuatT< T >::z
 

Definition at line 77 of file quat.h.

Referenced by NLMISC::CQuatT< T >::dotProduct(), NLMISC::CQuatT< T >::equal(), NLMISC::CQuatT< T >::operator *(), NLMISC::CQuatT< float >::operator+(), NLMISC::CQuatT< float >::operator+=(), NLMISC::CQuatT< float >::operator-(), NLMISC::CQuatT< float >::operator-=(), NLMISC::CQuatD::operator=(), NLMISC::CQuat::operator=(), and NLMISC::CQuatT< float >::operator==().

The documentation for this class was generated from the following file:
Generated on Tue Mar 16 13:30:51 2004 for NeL by doxygen 1.3.6