00001
00032 #ifndef LL_V2MATH_H
00033 #define LL_V2MATH_H
00034
00035 #include "llmath.h"
00036
00037 class LLVector4;
00038 class LLMatrix3;
00039 class LLQuaternion;
00040
00041
00042
00043 static const U32 LENGTHOFVECTOR2 = 2;
00044
00045 class LLVector2
00046 {
00047 public:
00048 F32 mV[LENGTHOFVECTOR2];
00049
00050 static LLVector2 zero;
00051
00052 LLVector2();
00053 LLVector2(F32 x, F32 y);
00054 LLVector2(const F32 *vec);
00055
00056
00057 void clear();
00058 void setZero();
00059 void clearVec();
00060 void zeroVec();
00061
00062 void set(F32 x, F32 y);
00063 void set(const LLVector2 &vec);
00064 void set(const F32 *vec);
00065
00066 void setVec(F32 x, F32 y);
00067 void setVec(const LLVector2 &vec);
00068 void setVec(const F32 *vec);
00069
00070 F32 length() const;
00071 F32 lengthSquared() const;
00072 F32 normalize();
00073
00074 F32 magVec() const;
00075 F32 magVecSquared() const;
00076 F32 normVec();
00077
00078 BOOL abs();
00079
00080 const LLVector2& scaleVec(const LLVector2& vec);
00081
00082 BOOL isNull();
00083 BOOL isExactlyZero() const { return !mV[VX] && !mV[VY]; }
00084
00085 F32 operator[](int idx) const { return mV[idx]; }
00086 F32 &operator[](int idx) { return mV[idx]; }
00087
00088 friend bool operator<(const LLVector2 &a, const LLVector2 &b);
00089 friend LLVector2 operator+(const LLVector2 &a, const LLVector2 &b);
00090 friend LLVector2 operator-(const LLVector2 &a, const LLVector2 &b);
00091 friend F32 operator*(const LLVector2 &a, const LLVector2 &b);
00092 friend LLVector2 operator%(const LLVector2 &a, const LLVector2 &b);
00093 friend LLVector2 operator/(const LLVector2 &a, F32 k);
00094 friend LLVector2 operator*(const LLVector2 &a, F32 k);
00095 friend LLVector2 operator*(F32 k, const LLVector2 &a);
00096 friend bool operator==(const LLVector2 &a, const LLVector2 &b);
00097 friend bool operator!=(const LLVector2 &a, const LLVector2 &b);
00098
00099 friend const LLVector2& operator+=(LLVector2 &a, const LLVector2 &b);
00100 friend const LLVector2& operator-=(LLVector2 &a, const LLVector2 &b);
00101 friend const LLVector2& operator%=(LLVector2 &a, const LLVector2 &b);
00102 friend const LLVector2& operator*=(LLVector2 &a, F32 k);
00103 friend const LLVector2& operator/=(LLVector2 &a, F32 k);
00104
00105 friend LLVector2 operator-(const LLVector2 &a);
00106
00107 friend std::ostream& operator<<(std::ostream& s, const LLVector2 &a);
00108 };
00109
00110
00111
00112
00113 F32 angle_between(const LLVector2 &a, const LLVector2 &b);
00114 BOOL are_parallel(const LLVector2 &a, const LLVector2 &b, F32 epsilon=F_APPROXIMATELY_ZERO);
00115 F32 dist_vec(const LLVector2 &a, const LLVector2 &b);
00116 F32 dist_vec_squared(const LLVector2 &a, const LLVector2 &b);
00117 F32 dist_vec_squared2D(const LLVector2 &a, const LLVector2 &b);
00118 LLVector2 lerp(const LLVector2 &a, const LLVector2 &b, F32 u);
00119
00120
00121
00122 inline LLVector2::LLVector2(void)
00123 {
00124 mV[VX] = 0.f;
00125 mV[VY] = 0.f;
00126 }
00127
00128 inline LLVector2::LLVector2(F32 x, F32 y)
00129 {
00130 mV[VX] = x;
00131 mV[VY] = y;
00132 }
00133
00134 inline LLVector2::LLVector2(const F32 *vec)
00135 {
00136 mV[VX] = vec[VX];
00137 mV[VY] = vec[VY];
00138 }
00139
00140
00141
00142
00143 inline void LLVector2::clear(void)
00144 {
00145 mV[VX] = 0.f;
00146 mV[VY] = 0.f;
00147 }
00148
00149 inline void LLVector2::setZero(void)
00150 {
00151 mV[VX] = 0.f;
00152 mV[VY] = 0.f;
00153 }
00154
00155
00156 inline void LLVector2::clearVec(void)
00157 {
00158 mV[VX] = 0.f;
00159 mV[VY] = 0.f;
00160 }
00161
00162
00163 inline void LLVector2::zeroVec(void)
00164 {
00165 mV[VX] = 0.f;
00166 mV[VY] = 0.f;
00167 }
00168
00169 inline void LLVector2::set(F32 x, F32 y)
00170 {
00171 mV[VX] = x;
00172 mV[VY] = y;
00173 }
00174
00175 inline void LLVector2::set(const LLVector2 &vec)
00176 {
00177 mV[VX] = vec.mV[VX];
00178 mV[VY] = vec.mV[VY];
00179 }
00180
00181 inline void LLVector2::set(const F32 *vec)
00182 {
00183 mV[VX] = vec[VX];
00184 mV[VY] = vec[VY];
00185 }
00186
00187
00188
00189 inline void LLVector2::setVec(F32 x, F32 y)
00190 {
00191 mV[VX] = x;
00192 mV[VY] = y;
00193 }
00194
00195
00196 inline void LLVector2::setVec(const LLVector2 &vec)
00197 {
00198 mV[VX] = vec.mV[VX];
00199 mV[VY] = vec.mV[VY];
00200 }
00201
00202
00203 inline void LLVector2::setVec(const F32 *vec)
00204 {
00205 mV[VX] = vec[VX];
00206 mV[VY] = vec[VY];
00207 }
00208
00209
00210
00211 inline F32 LLVector2::length(void) const
00212 {
00213 return fsqrtf(mV[0]*mV[0] + mV[1]*mV[1]);
00214 }
00215
00216 inline F32 LLVector2::lengthSquared(void) const
00217 {
00218 return mV[0]*mV[0] + mV[1]*mV[1];
00219 }
00220
00221 inline F32 LLVector2::normalize(void)
00222 {
00223 F32 mag = fsqrtf(mV[0]*mV[0] + mV[1]*mV[1]);
00224 F32 oomag;
00225
00226 if (mag > FP_MAG_THRESHOLD)
00227 {
00228 oomag = 1.f/mag;
00229 mV[0] *= oomag;
00230 mV[1] *= oomag;
00231 }
00232 else
00233 {
00234 mV[0] = 0.f;
00235 mV[1] = 0.f;
00236 mag = 0;
00237 }
00238 return (mag);
00239 }
00240
00241
00242 inline F32 LLVector2::magVec(void) const
00243 {
00244 return fsqrtf(mV[0]*mV[0] + mV[1]*mV[1]);
00245 }
00246
00247
00248 inline F32 LLVector2::magVecSquared(void) const
00249 {
00250 return mV[0]*mV[0] + mV[1]*mV[1];
00251 }
00252
00253
00254 inline F32 LLVector2::normVec(void)
00255 {
00256 F32 mag = fsqrtf(mV[0]*mV[0] + mV[1]*mV[1]);
00257 F32 oomag;
00258
00259 if (mag > FP_MAG_THRESHOLD)
00260 {
00261 oomag = 1.f/mag;
00262 mV[0] *= oomag;
00263 mV[1] *= oomag;
00264 }
00265 else
00266 {
00267 mV[0] = 0.f;
00268 mV[1] = 0.f;
00269 mag = 0;
00270 }
00271 return (mag);
00272 }
00273
00274 inline const LLVector2& LLVector2::scaleVec(const LLVector2& vec)
00275 {
00276 mV[VX] *= vec.mV[VX];
00277 mV[VY] *= vec.mV[VY];
00278
00279 return *this;
00280 }
00281
00282 inline BOOL LLVector2::isNull()
00283 {
00284 if ( F_APPROXIMATELY_ZERO > mV[VX]*mV[VX] + mV[VY]*mV[VY] )
00285 {
00286 return TRUE;
00287 }
00288 return FALSE;
00289 }
00290
00291
00292
00293
00294
00295 inline bool operator<(const LLVector2 &a, const LLVector2 &b)
00296 {
00297 if( a.mV[VX] == b.mV[VX] )
00298 {
00299 return a.mV[VY] < b.mV[VY];
00300 }
00301 else
00302 {
00303 return a.mV[VX] < b.mV[VX];
00304 }
00305 }
00306
00307
00308 inline LLVector2 operator+(const LLVector2 &a, const LLVector2 &b)
00309 {
00310 LLVector2 c(a);
00311 return c += b;
00312 }
00313
00314 inline LLVector2 operator-(const LLVector2 &a, const LLVector2 &b)
00315 {
00316 LLVector2 c(a);
00317 return c -= b;
00318 }
00319
00320 inline F32 operator*(const LLVector2 &a, const LLVector2 &b)
00321 {
00322 return (a.mV[0]*b.mV[0] + a.mV[1]*b.mV[1]);
00323 }
00324
00325 inline LLVector2 operator%(const LLVector2 &a, const LLVector2 &b)
00326 {
00327 return LLVector2(a.mV[0]*b.mV[1] - b.mV[0]*a.mV[1], a.mV[1]*b.mV[0] - b.mV[1]*a.mV[0]);
00328 }
00329
00330 inline LLVector2 operator/(const LLVector2 &a, F32 k)
00331 {
00332 F32 t = 1.f / k;
00333 return LLVector2( a.mV[0] * t, a.mV[1] * t );
00334 }
00335
00336 inline LLVector2 operator*(const LLVector2 &a, F32 k)
00337 {
00338 return LLVector2( a.mV[0] * k, a.mV[1] * k );
00339 }
00340
00341 inline LLVector2 operator*(F32 k, const LLVector2 &a)
00342 {
00343 return LLVector2( a.mV[0] * k, a.mV[1] * k );
00344 }
00345
00346 inline bool operator==(const LLVector2 &a, const LLVector2 &b)
00347 {
00348 return ( (a.mV[0] == b.mV[0])
00349 &&(a.mV[1] == b.mV[1]));
00350 }
00351
00352 inline bool operator!=(const LLVector2 &a, const LLVector2 &b)
00353 {
00354 return ( (a.mV[0] != b.mV[0])
00355 ||(a.mV[1] != b.mV[1]));
00356 }
00357
00358 inline const LLVector2& operator+=(LLVector2 &a, const LLVector2 &b)
00359 {
00360 a.mV[0] += b.mV[0];
00361 a.mV[1] += b.mV[1];
00362 return a;
00363 }
00364
00365 inline const LLVector2& operator-=(LLVector2 &a, const LLVector2 &b)
00366 {
00367 a.mV[0] -= b.mV[0];
00368 a.mV[1] -= b.mV[1];
00369 return a;
00370 }
00371
00372 inline const LLVector2& operator%=(LLVector2 &a, const LLVector2 &b)
00373 {
00374 LLVector2 ret(a.mV[0]*b.mV[1] - b.mV[0]*a.mV[1], a.mV[1]*b.mV[0] - b.mV[1]*a.mV[0]);
00375 a = ret;
00376 return a;
00377 }
00378
00379 inline const LLVector2& operator*=(LLVector2 &a, F32 k)
00380 {
00381 a.mV[0] *= k;
00382 a.mV[1] *= k;
00383 return a;
00384 }
00385
00386 inline const LLVector2& operator/=(LLVector2 &a, F32 k)
00387 {
00388 F32 t = 1.f / k;
00389 a.mV[0] *= t;
00390 a.mV[1] *= t;
00391 return a;
00392 }
00393
00394 inline LLVector2 operator-(const LLVector2 &a)
00395 {
00396 return LLVector2( -a.mV[0], -a.mV[1] );
00397 }
00398
00399 inline void update_min_max(LLVector2& min, LLVector2& max, const LLVector2& pos)
00400 {
00401 for (U32 i = 0; i < 2; i++)
00402 {
00403 if (min.mV[i] > pos.mV[i])
00404 {
00405 min.mV[i] = pos.mV[i];
00406 }
00407 if (max.mV[i] < pos.mV[i])
00408 {
00409 max.mV[i] = pos.mV[i];
00410 }
00411 }
00412 }
00413
00414 inline std::ostream& operator<<(std::ostream& s, const LLVector2 &a)
00415 {
00416 s << "{ " << a.mV[VX] << ", " << a.mV[VY] << " }";
00417 return s;
00418 }
00419
00420 #endif