Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals

/Users/blackie/Documents/myRepository/phobosengine-vc2005/phobosengine/phobosengine/Vector3f.cpp

Go to the documentation of this file.
00001 
00002 
00003 #include <math.h>
00004 
00005 #include "Vector3f.h"
00006 
00007 
00008 namespace pge {
00009 
00010 
00011         //****************************************************************************
00012         //
00013         //
00014         //
00015         //****************************************************************************
00016         Vector3f::Vector3f(void) {
00017                 m_v[0] = 0.0f;
00018                 m_v[1] = 0.0f;
00019                 m_v[2] = 0.0f;
00020         }
00021 
00022 
00023         //****************************************************************************
00024         //
00025         //
00026         //
00027         //****************************************************************************
00028         Vector3f::Vector3f(float x, float y, float z) {
00029                 m_v[0] = x;
00030                 m_v[1] = y;
00031                 m_v[2] = z;
00032         }
00033 
00034 
00035         //****************************************************************************
00036         //
00037         //
00038         //
00039         //****************************************************************************
00040         Vector3f::Vector3f(float v[3]) {
00041                 m_v[0] = v[0];
00042                 m_v[1] = v[1];
00043                 m_v[2] = v[2];
00044         }
00045 
00046 
00047         //****************************************************************************
00048         //
00049         //
00050         //
00051         //****************************************************************************
00052         Vector3f::Vector3f(const Vector3f &copy) {
00053                 m_v[0] = copy.m_v[0];
00054                 m_v[1] = copy.m_v[1];
00055                 m_v[2] = copy.m_v[2];
00056         }
00057 
00058 
00059         //****************************************************************************
00060         //
00061         //
00062         //
00063         //****************************************************************************
00064         Vector3f::Vector3f(const Vector4f &vec) {
00065                 m_v[0] = vec.m_v[0];
00066                 m_v[1] = vec.m_v[1];
00067                 m_v[2] = vec.m_v[2];
00068         }
00069 
00070 
00071         //****************************************************************************
00072         //
00073         //
00074         //
00075         //****************************************************************************
00076         Vector3f::~Vector3f(void) {
00077         }
00078 
00079 
00080         //****************************************************************************
00081         //
00082         //
00083         //
00084         //****************************************************************************
00085         Vector3f Vector3f::add(const Vector3f &v) {
00086                 Vector3f res = Vector3f(m_v[0] + v.m_v[0], m_v[1] + v.m_v[1], m_v[2] + v.m_v[2]);
00087                 return res;
00088         }
00089 
00090 
00091         //****************************************************************************
00092         //
00093         //
00094         //
00095         //****************************************************************************
00096         Vector3f Vector3f::add(float c) {
00097                 Vector3f res = Vector3f(m_v[0] + c, m_v[1] + c, m_v[2] + c);
00098                 return res;
00099         }
00100 
00101 
00102         //****************************************************************************
00103         //
00104         //
00105         //
00106         //****************************************************************************
00107         Vector3f Vector3f::subtract(const Vector3f &v) {
00108                 Vector3f res = Vector3f(m_v[0] - v.m_v[0], m_v[1] - v.m_v[1], m_v[2] - v.m_v[2]);
00109                 return res;
00110         }
00111 
00112 
00113         //****************************************************************************
00114         //
00115         //
00116         //
00117         //****************************************************************************
00118         Vector3f Vector3f::subtract(float c) {
00119                 Vector3f res = Vector3f(m_v[0] - c, m_v[1] - c, m_v[2] - c);
00120                 return res;
00121         }
00122 
00123 
00124         //****************************************************************************
00125         //
00126         //
00127         //
00128         //****************************************************************************
00129         Vector3f Vector3f::divide(const Vector3f &v) {
00130                 Vector3f res = Vector3f(m_v[0] / v.m_v[0], m_v[1] / v.m_v[1], m_v[2] / v.m_v[2]);
00131                 return res;
00132         }
00133 
00134 
00135         //****************************************************************************
00136         //
00137         //
00138         //
00139         //****************************************************************************
00140         Vector3f Vector3f::divide(float c) {
00141                 Vector3f res = Vector3f(m_v[0] / c, m_v[1] / c, m_v[2] / c);
00142                 return res;
00143         }
00144 
00145 
00146         //****************************************************************************
00147         //
00148         //
00149         //
00150         //****************************************************************************
00151         Vector3f Vector3f::multiply(const Vector3f &v) {
00152                 Vector3f res = Vector3f(m_v[0] * v.m_v[0], m_v[1] * v.m_v[1], m_v[2] * v.m_v[2]);
00153                 return res;
00154         }
00155 
00156 
00157         //****************************************************************************
00158         //
00159         //
00160         //
00161         //****************************************************************************
00162         Vector3f Vector3f::multiply(float c) {
00163                 Vector3f res = Vector3f(m_v[0] * c, m_v[1] * c, m_v[2] * c);
00164                 return res;
00165         }
00166 
00167 
00168         //****************************************************************************
00169         //
00170         //
00171         //
00172         //****************************************************************************
00173         float Vector3f::sqrMagnitude(void) {
00174                 return ((m_v[0] * m_v[0]) + (m_v[1] * m_v[1]) + (m_v[2] * m_v[2]));
00175         }
00176 
00177 
00178         //****************************************************************************
00179         //
00180         //
00181         //
00182         //****************************************************************************
00183         float Vector3f::magnitude(void) {
00184                 return ((float)sqrt((m_v[0] * m_v[0]) + (m_v[1] * m_v[1]) + (m_v[2] * m_v[2])));
00185         }
00186 
00187 
00188         //****************************************************************************
00189         //
00190         //
00191         //
00192         //****************************************************************************
00193         float Vector3f::dotProduct(const Vector3f &v) {
00194                 return ((m_v[0] * v.m_v[0]) + (m_v[1] * v.m_v[1]) + (m_v[2] * v.m_v[2]));
00195         }
00196 
00197 
00198         //****************************************************************************
00199         //
00200         //
00201         //
00202         //****************************************************************************
00203         void Vector3f::normalize(void) {
00204                 // calculate 1 / length of vector
00205                 float f = 1.0f / magnitude();
00206 
00207                 // multiply this value with the vector. this is the new normalized vector
00208                 m_v[0] = m_v[0] * f;
00209                 m_v[1] = m_v[1] * f;
00210                 m_v[2] = m_v[2] * f;
00211 
00212         }
00213 
00214 
00215         //****************************************************************************
00216         //
00217         //
00218         //
00219         //****************************************************************************
00220         Vector3f Vector3f::crossProduct(const Vector3f &v) {
00221                 Vector3f res = Vector3f((m_v[1] * v.m_v[2]) - (m_v[2] * v.m_v[1]), (m_v[2] * v.m_v[0]) - (m_v[0] * v.m_v[2]),
00222                         (m_v[0] * v.m_v[1]) - (m_v[1] * v.m_v[0]));
00223                 return res;
00224         }
00225 
00226 
00227         //****************************************************************************
00228         //
00229         //
00230         //
00231         //****************************************************************************
00232         float Vector3f::angle(Vector3f v) {
00233                 return ((float)acos(dotProduct(v) / (magnitude() * v.magnitude())) / (float)PIOVER180);
00234         }
00235 
00236 
00237         //****************************************************************************
00238         //
00239         //
00240         //
00241         //****************************************************************************
00242         float Vector3f::sqrDistance(const Vector3f &v) {
00243                 return ((m_v[0] - v.m_v[0]) * (m_v[0] - v.m_v[0])) +
00244                         ((m_v[1] - v.m_v[1]) * (m_v[1] - v.m_v[1])) +
00245                         ((m_v[2] - v.m_v[2]) * (m_v[2] - v.m_v[2]));
00246         }
00247 
00248 
00249         //****************************************************************************
00250         //
00251         //
00252         //
00253         //****************************************************************************
00254         float Vector3f::distance(const Vector3f &v) {
00255                 return ((float)(sqrt(((m_v[0] - v.m_v[0]) * (m_v[0] - v.m_v[0])) +
00256                         ((m_v[1] - v.m_v[1]) * (m_v[1] - v.m_v[1])) +
00257                         ((m_v[2] - v.m_v[2]) * (m_v[2] - v.m_v[2]))
00258                         )));
00259         }
00260 
00261 
00262         //****************************************************************************
00263         //
00264         //
00265         //
00266         //****************************************************************************
00267         bool Vector3f::isNullVector(void) {
00268                 if (m_v[0] != 0.0f || m_v[1] != 0.0f || m_v[2] != 0.0f) {
00269                         return false;
00270                 }
00271                 return true;
00272         }
00273 
00274 
00275         //****************************************************************************
00276         //
00277         //
00278         //
00279         //****************************************************************************
00280         bool Vector3f::equals(const Vector3f &v) {
00281                 if(abs(m_v[0] - v.m_v[0]) <= EQUAL_TOLERANCE
00282                         && abs(m_v[1] - v.m_v[1]) <= EQUAL_TOLERANCE
00283                         && abs(m_v[2] - v.m_v[2]) <= EQUAL_TOLERANCE) {
00284                                 return true;
00285                 } else {
00286                         return false;
00287                 }
00288         }
00289 
00290 
00291         //****************************************************************************
00292         //
00293         //
00294         //
00295         //****************************************************************************
00296         Vector3f Vector3f::closestPointOnLine(Vector3f lineStart, Vector3f lineEnd) {
00297                 Vector3f c = this->subtract(lineStart);
00298                 Vector3f V = lineEnd.subtract(lineStart);
00299 
00300 
00301                 V.normalize();
00302                 float d = lineStart.distance(lineEnd);
00303                 float t = V.dotProduct(c);
00304 
00305                 // Check to see if t is beyond the extents of the line segment.
00306                 if(t < 0.0f) {
00307                         return lineStart;
00308                 }
00309                 if(t > d){ 
00310                         return lineEnd;
00311                 }
00312                 // Return the point between a and b.
00313                 // Set length of V to t.
00314                 V = V.multiply(t);
00315 
00316                 return lineStart.add(V);
00317         }
00318 
00319 
00320         //****************************************************************************
00321         //
00322         //
00323         //
00324         //****************************************************************************
00325         Vector3f Vector3f::createNormal(Vector3f a, Vector3f b, Vector3f c) {
00326                 Vector3f u;
00327                 Vector3f v;
00328                 Vector3f normal;
00329 
00330                 // Get the spanning vectors for the plane.
00331                 u = b.subtract(a);
00332                 v = c.subtract(a);
00333 
00334                 normal = u.crossProduct(v);
00335                 normal.normalize();
00336                 return normal;
00337         }
00338 
00339 
00340         //****************************************************************************
00341         //
00342         //
00343         //
00344         //****************************************************************************
00345         std::string Vector3f::toString(void) {
00346                 //return std::string("X: " + m_v[0] + " Y: " + m_v[1] + " Z: " + m_v[2]);
00347                 return std::string("TODO");
00348         }
00349 };

Generated on Mon Oct 16 12:08:11 2006 for Phobosengine by doxygen 1.3.4