NeL: NLMISC::CVector class Reference

00069 : x(_x), y(_y), z(_z) {}

00071 : x(v.x), y(v.y), z(v.z) {}

00139 { return toString(); }

00162 {
00163         CVector v;
00164 
00165         r= norm();
00166         v= normed();
00167 
00168         // phi E [-PI/2 et PI/2]
00169         clamp(v.z, -1.0f, 1.0f);
00170         phi= (float)asin(v.z);
00171 
00172         // theta [-PI,PI]
00173         theta= (float)atan2(v.y,v.x);
00174 }

00149 {
00150         return *this==CVector::Null;
00151 }

00193 {
00194         x= std::max(a.x, b.x);
00195         y= std::max(a.y, b.y);
00196         z= std::max(a.z, b.z);
00197 }

00187 {
00188         x= std::min(a.x, b.x);
00189         y= std::min(a.y, b.y);
00190         z= std::min(a.z, b.z);
00191 }

00116 {
00117         return (float)sqrt(x*x + y*y + z*z);
00118 }

00120 {
00121         float   n=norm();
00122         if(n)
00123                 *this/=n;
00124 }

00126 {
00127         CVector ret;
00128         ret= *this;
00129         ret.normalize();
00130         return ret;
00131 }

00098 {
00099         return x*v.x + y*v.y + z*v.z;
00100 }

00076 {
00077         CVector ret(x*f, y*f, z*f);
00078         return ret;
00079 }

00055 {
00056         x*=f;
00057         y*=f;
00058         z*=f;
00059         return *this;
00060 }

00145 {
00146         return !(*this==v);
00147 }

00066 {
00067         CVector ret(x+v.x, y+v.y, z+v.z);
00068         return ret;
00069 }

00041 {
00042         x+=v.x;
00043         y+=v.y;
00044         z+=v.z;
00045         return *this;
00046 }

00085 {
00086         return CVector(-x,-y,-z);
00087 }

00071 {
00072         CVector ret(x-v.x, y-v.y, z-v.z);
00073         return ret;
00074 }

00048 {
00049         x-=v.x;
00050         y-=v.y;
00051         z-=v.z;
00052         return *this;
00053 }

00081 {
00082         return *this*(1.0f/f);
00083 }

00062 {
00063         return *this*= (1.0f/f);
00064 }

00153 {
00154         if(x!=v.x)
00155                 return x<v.x;
00156         if(y!=v.y)
00157                 return y<v.y;
00158         return z<v.z;
00159 }

00141 {
00142         return x==v.x && y==v.y && z==v.z;
00143 }

00102 {
00103         CVector ret;
00104 
00105         ret.x= y*v.z - z*v.y;
00106         ret.y= z*v.x - x*v.z;
00107         ret.z= x*v.y - y*v.x;
00108 
00109         return ret;
00110 }

00199 {
00200         f.serial(x,y,z);
00201 }

00137 {
00138         x=_x; y=_y; z=_z;
00139 }

00176 {
00177         double  ct= cos(theta);
00178         double  st= sin(theta);
00179         double  cp= cos(phi);
00180         double  sp= sin(phi);
00181 
00182         x= (float)(r*ct*cp);
00183         y= (float)(r*st*cp);
00184         z= (float)(r*sp);
00185 }

00112 {
00113         return (float)(x*x + y*y + z*z);
00114 }

00046 {
00047         string str;
00048         str = NLMISC::toString(x) + " " + NLMISC::toString(y) + " " + NLMISC::toString(z);
00049         return str;
00050 }

00089 {
00090         CVector ret(v.x*f, v.y*f, v.z*f);
00091         return ret;
00092 }


Public Member Functions
std::string	asString () const
std::string	toString () const
	Returns the contents as a printable string "x y z".
Object.
	CVector (const CVector &v)
	Copy Constructor.
	CVector (float _x, float _y, float _z)
	Constructor .
	CVector ()
	Constructor wich do nothing.
Data Fields
float	x
float	y
float	z
Static Public Attributes
const CVector	I
	I vector (1,0,0).
const CVector	J
	J vector (0,1,0).
const CVector	K
	K vector (0,0,1).
const CVector	Null
	Null vector (0,0,0).
Friends
CVector	operator * (float f, const CVector &v0)

NLMISC::CVector Class Reference

Detailed Description

Public Member Functions

Data Fields

Static Public Attributes

Friends

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Field Documentation