nevrax.org : docs

00001 
+00007 /* Copyright, 2000 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 
+00027 #ifndef NL_VECTORD_INLINE_H
+00028 #define NL_VECTORD_INLINE_H
+00029 
+00030 
+00031 #include "nel/misc/common.h"
+00032 
+00033 
+00034 namespace       NLMISC
+00035 {
+00036 
+00037 
+00038 // ============================================================================================
+00039 // Base Maths.
+00040 inline  CVectorD        &CVectorD::operator+=(const CVectorD &v)
+00041 {
+00042         x+=v.x;
+00043         y+=v.y;
+00044         z+=v.z;
+00045         return *this;
+00046 }
+00047 inline  CVectorD        &CVectorD::operator-=(const CVectorD &v)
+00048 {
+00049         x-=v.x;
+00050         y-=v.y;
+00051         z-=v.z;
+00052         return *this;
+00053 }
+00054 inline  CVectorD        &CVectorD::operator*=(double f)
+00055 {
+00056         x*=f;
+00057         y*=f;
+00058         z*=f;
+00059         return *this;
+00060 }
+00061 inline  CVectorD        &CVectorD::operator/=(double f)
+00062 {
+00063         return *this*= (1.0f/f);
+00064 }
+00065 inline  CVectorD        CVectorD::operator+(const CVectorD &v) const
+00066 {
+00067         CVectorD        ret(x+v.x, y+v.y, z+v.z);
+00068         return ret;
+00069 }
+00070 inline  CVectorD        CVectorD::operator-(const CVectorD &v) const
+00071 {
+00072         CVectorD        ret(x-v.x, y-v.y, z-v.z);
+00073         return ret;
+00074 }
+00075 inline  CVectorD        CVectorD::operator*(double f) const
+00076 {
+00077         CVectorD        ret(x*f, y*f, z*f);
+00078         return ret;
+00079 }
+00080 inline  CVectorD        CVectorD::operator/(double f) const
+00081 {
+00082         return *this*(1.0f/f);
+00083 }
+00084 inline  CVectorD        CVectorD::operator-() const
+00085 {
+00086         return CVectorD(-x,-y,-z);
+00087 }
+00088 inline CVectorD operator*(double f, const CVectorD &v)
+00089 {
+00090         CVectorD        ret(v.x*f, v.y*f, v.z*f);
+00091         return ret;
+00092 }
+00093 
+00094 
+00095 // ============================================================================================
+00096 // Advanced Maths.
+00097 inline  double  CVectorD::operator*(const CVectorD &v) const
+00098 {
+00099         return x*v.x + y*v.y + z*v.z;
+00100 }
+00101 inline  CVectorD        CVectorD::operator^(const CVectorD &v) const
+00102 {
+00103         CVectorD        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 }
+00111 inline  double  CVectorD::sqrnorm() const
+00112 {
+00113         return (double)(x*x + y*y + z*z);
+00114 }
+00115 inline  double  CVectorD::norm() const
+00116 {
+00117         return (double)sqrt(x*x + y*y + z*z);
+00118 }
+00119 inline  void    CVectorD::normalize()
+00120 {
+00121         double  n=norm();
+00122         if(n)
+00123                 *this/=n;
+00124 }
+00125 inline  CVectorD        CVectorD::normed() const
+00126 {
+00127         CVectorD        ret;
+00128         ret= *this;
+00129         ret.normalize();
+00130         return ret;
+00131 }
+00132 
+00133 
+00134 // ============================================================================================
+00135 // Misc.
+00136 inline  void    CVectorD::set(double _x, double _y, double _z)
+00137 {
+00138         x=_x; y=_y; z=_z;
+00139 }
+00140 inline  bool    CVectorD::operator==(const CVectorD &v) const 
+00141 {
+00142         return x==v.x && y==v.y && z==v.z;
+00143 }
+00144 inline  bool    CVectorD::operator!=(const CVectorD &v) const 
+00145 {
+00146         return !(*this==v);
+00147 }
+00148 inline  bool    CVectorD::isNull() const
+00149 {
+00150         return *this==CVectorD::Null;
+00151 }
+00152 inline  void    CVectorD::cartesianToSpheric(double &r, double &theta,double &phi) const
+00153 {
+00154         CVectorD v;
+00155 
+00156         r= norm();
+00157         v= normed();
+00158 
+00159         // phi E [-PI/2 et PI/2]
+00160         clamp(v.z, -1.0, 1.0);
+00161         phi=asin(v.z);
+00162 
+00163         // theta [-PI,PI]
+00164         theta=atan2(v.y,v.x);
+00165 }
+00166 inline  void    CVectorD::sphericToCartesian(double r, double theta,double phi)
+00167 {
+00168         x= r*cos(theta)*cos(phi);
+00169         y= r*sin(theta)*cos(phi);
+00170         z= r*sin(phi);
+00171 }
+00172 inline CVectorD &CVectorD::operator=(const CVector &v)
+00173 {
+00174         x=v.x;
+00175         y=v.y;
+00176         z=v.z;
+00177         return *this;
+00178 }
+00179 inline CVectorD::operator CVector() const
+00180 {
+00181         return CVector((float)x, (float)y, (float)z);
+00182 }
+00183 inline  void    CVectorD::serial(IStream &f)
+00184 {
+00185         f.serial(x,y,z);
+00186 }
+00187 
+00188 
+00189 }
+00190 
+00191 
+00192 #endif
+00193 
+
vectord_inline.h
