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