Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

nv_algebra.h

Go to the documentation of this file.
00001 /*********************************************************************NVMH1****
00002 File:
00003 nv_algebra.h
00004 
00005 Copyright (C) 1999, 2002 NVIDIA Corporation
00006 This file is provided without support, instruction, or implied warranty of any
00007 kind.  NVIDIA makes no guarantee of its fitness for a particular purpose and is
00008 not liable under any circumstances for any damages or loss whatsoever arising
00009 from the use or inability to use this file or items derived from it.
00010 
00011 Comments:
00012 
00013 
00014 ******************************************************************************/
00015 
00016 #ifndef _nv_algebra_h_
00017 #define _nv_algebra_h_
00018 
00019 struct DECLSPEC_NV_MATH vec2
00020 {
00021     vec2() { }
00022     vec2(nv_scalar x, nv_scalar y) : x(x), y(y) { }
00023     vec2(const nv_scalar* xy) : x(xy[0]), y(xy[1]) { }
00024     vec2(const vec2& u) : x(u.x), y(u.y) { }
00025     vec2(const vec3&);
00026 
00027     bool operator==(const vec2 & u) const
00028     {
00029         return (u.x == x && u.y == y) ? true : false;
00030     }
00031 
00032     bool operator!=(const vec2 & u) const
00033     {
00034         return !(*this == u );
00035     }
00036 
00037     vec2 & operator*=(const nv_scalar & lambda)
00038     {
00039         x*= lambda;
00040         y*= lambda;
00041         return *this;
00042     }
00043 
00044     vec2 & operator-=(const vec2 & u)
00045     {
00046         x-= u.x;
00047         y-= u.y;
00048         return *this;
00049     }
00050 
00051     vec2 & operator+=(const vec2 & u)
00052     {
00053         x+= u.x;
00054         y+= u.y;
00055         return *this;
00056     }
00057 
00058     nv_scalar & operator[](int i)
00059     {
00060         return vec_array[i];
00061     }
00062 
00063     const nv_scalar operator[](int i) const
00064     {
00065         return vec_array[i];
00066     }
00067 
00068     union {
00069         struct {
00070             nv_scalar x,y;          // standard names for components
00071         };
00072         struct {
00073             nv_scalar s,t;          // standard names for components
00074         };
00075         nv_scalar vec_array[2];     // array access
00076     };
00077 };
00078 
00079 inline const vec2 operator+(const vec2& u, const vec2& v)
00080 {
00081     return vec2(u.x + v.x, u.y + v.y);
00082 }
00083 
00084 inline const vec2 operator-(const vec2& u, const vec2& v)
00085 {
00086     return vec2(u.x - v.x, u.y - v.y);
00087 }
00088 
00089 inline const vec2 operator*(const nv_scalar s, const vec2& u)
00090 {
00091     return vec2(s * u.x, s * u.y);
00092 }
00093 
00094 inline const vec2 operator/(const vec2& u, const nv_scalar s)
00095 {
00096     return vec2(u.x / s, u.y / s);
00097 }
00098 
00099 inline const vec2 operator*(const vec2&u, const vec2&v)
00100 {
00101     return vec2(u.x * v.x, u.y * v.y);
00102 }
00103 
00104 struct DECLSPEC_NV_MATH vec3
00105 {
00106     vec3() { }
00107     vec3(nv_scalar x, nv_scalar y, nv_scalar z) : x(x), y(y), z(z) { }
00108     vec3(const nv_scalar* xyz) : x(xyz[0]), y(xyz[1]), z(xyz[2]) { }
00109     vec3(const vec2& u) : x(u.x), y(u.y), z(1.0f) { }
00110     vec3(const vec3& u) : x(u.x), y(u.y), z(u.z) { }
00111     vec3(const vec4&);
00112 
00113     bool operator==(const vec3 & u) const
00114     {
00115         return (u.x == x && u.y == y && u.z == z) ? true : false;
00116     }
00117 
00118     bool operator!=( const vec3& rhs ) const
00119     {
00120         return !(*this == rhs );
00121     }
00122 
00123     vec3 & operator*=(const nv_scalar & lambda)
00124     {
00125         x*= lambda;
00126         y*= lambda;
00127         z*= lambda;
00128         return *this;
00129     }
00130 
00131     vec3 operator - () const
00132     {
00133         return vec3(-x, -y, -z);
00134     }
00135 
00136     vec3 & operator-=(const vec3 & u)
00137     {
00138         x-= u.x;
00139         y-= u.y;
00140         z-= u.z;
00141         return *this;
00142     }
00143 
00144     vec3 & operator+=(const vec3 & u)
00145     {
00146         x+= u.x;
00147         y+= u.y;
00148         z+= u.z;
00149         return *this;
00150     }
00151     nv_scalar normalize();
00152     nv_scalar sq_norm() const { return x * x + y * y + z * z; }
00153     nv_scalar norm() const { return sqrtf(sq_norm()); }
00154 
00155     nv_scalar & operator[](int i)
00156     {
00157         return vec_array[i];
00158     }
00159 
00160     const nv_scalar operator[](int i) const
00161     {
00162         return vec_array[i];
00163     }
00164 
00165     union {
00166         struct {
00167             nv_scalar x,y,z;        // standard names for components
00168         };
00169         struct {
00170             nv_scalar s,t,r;        // standard names for components
00171         };
00172         nv_scalar vec_array[3];     // array access
00173     };
00174 };
00175 
00176 inline const vec3 operator+(const vec3& u, const vec3& v)
00177 {
00178     return vec3(u.x + v.x, u.y + v.y, u.z + v.z);
00179 }
00180 
00181 inline const vec3 operator-(const vec3& u, const vec3& v)
00182 {
00183     return vec3(u.x - v.x, u.y - v.y, u.z - v.z);
00184 }
00185 
00186 inline const vec3 operator^(const vec3& u, const vec3& v)
00187 {
00188     return vec3(u.y * v.z - u.z * v.y, u.z * v.x - u.x * v.z, u.x * v.y - u.y * v.x);
00189 }
00190 
00191 inline const vec3 operator*(const nv_scalar s, const vec3& u)
00192 {
00193     return vec3(s * u.x, s * u.y, s * u.z);
00194 }
00195 
00196 inline const vec3 operator/(const vec3& u, const nv_scalar s)
00197 {
00198     return vec3(u.x / s, u.y / s, u.z / s);
00199 }
00200 
00201 inline const vec3 operator*(const vec3& u, const vec3& v)
00202 {
00203     return vec3(u.x * v.x, u.y * v.y, u.z * v.z);
00204 }
00205 
00206 inline vec2::vec2(const vec3& u)
00207 {
00208     nv_scalar k = 1 / u.z;
00209     x = k * u.x;
00210     y = k * u.y;
00211 }
00212 
00213 struct DECLSPEC_NV_MATH vec4
00214 {
00215     vec4() { }
00216     vec4(nv_scalar x, nv_scalar y, nv_scalar z, nv_scalar w) : x(x), y(y), z(z), w(w) { }
00217     vec4(const nv_scalar* xyzw) : x(xyzw[0]), y(xyzw[1]), z(xyzw[2]), w(xyzw[3]) { }
00218     vec4(const vec3& u) : x(u.x), y(u.y), z(u.z), w(1.0f) { }
00219     vec4(const vec4& u) : x(u.x), y(u.y), z(u.z), w(u.w) { }
00220 
00221     bool operator==(const vec4 & u) const
00222     {
00223         return (u.x == x && u.y == y && u.z == z && u.w == w) ? true : false;
00224     }
00225 
00226     bool operator!=( const vec4& rhs ) const
00227     {
00228         return !(*this == rhs );
00229     }
00230 
00231 
00232     vec4 & operator*=(const nv_scalar & lambda)
00233     {
00234         x*= lambda;
00235         y*= lambda;
00236         z*= lambda;
00237         w*= lambda;
00238         return *this;
00239     }
00240 
00241     vec4 & operator-=(const vec4 & u)
00242     {
00243         x-= u.x;
00244         y-= u.y;
00245         z-= u.z;
00246         w-= u.w;
00247         return *this;
00248     }
00249 
00250     vec4 & operator+=(const vec4 & u)
00251     {
00252         x+= u.x;
00253         y+= u.y;
00254         z+= u.z;
00255         w+= u.w;
00256         return *this;
00257     }
00258 
00259     vec4 operator - () const
00260     {
00261         return vec4(-x, -y, -z, -w);
00262     }
00263 
00264     nv_scalar & operator[](int i)
00265     {
00266         return vec_array[i];
00267     }
00268 
00269     const nv_scalar operator[](int i) const
00270     {
00271         return vec_array[i];
00272     }
00273 
00274     union {
00275         struct {
00276             nv_scalar x,y,z,w;          // standard names for components
00277         };
00278         struct {
00279             nv_scalar s,t,r,q;          // standard names for components
00280         };
00281         nv_scalar vec_array[4];     // array access
00282     };
00283 };
00284 
00285 inline const vec4 operator+(const vec4& u, const vec4& v)
00286 {
00287     return vec4(u.x + v.x, u.y + v.y, u.z + v.z, u.w + v.w);
00288 }
00289 
00290 inline const vec4 operator-(const vec4& u, const vec4& v)
00291 {
00292     return vec4(u.x - v.x, u.y - v.y, u.z - v.z, u.w - v.w);
00293 }
00294 
00295 inline const vec4 operator*(const nv_scalar s, const vec4& u)
00296 {
00297     return vec4(s * u.x, s * u.y, s * u.z, s * u.w);
00298 }
00299 
00300 inline const vec4 operator/(const vec4& u, const nv_scalar s)
00301 {
00302     return vec4(u.x / s, u.y / s, u.z / s, u.w / s);
00303 }
00304 
00305 inline const vec4 operator*(const vec4& u, const vec4& v)
00306 {
00307     return vec4(u.x * v.x, u.y * v.y, u.z * v.z, u.w * v.w);
00308 }
00309 
00310 inline vec3::vec3(const vec4& u)
00311 {
00312     x = u.x;
00313     y = u.y;
00314     z = u.z;
00315 }
00316 
00317 // quaternion
00318 struct quat;  
00319 
00320 /*
00321     for all the matrices...a<x><y> indicates the element at row x, col y
00322 
00323     For example:
00324     a01 <-> row 0, col 1 
00325 */
00326 
00327 struct DECLSPEC_NV_MATH mat3
00328 {
00329     mat3();
00330     mat3(const nv_scalar * array);
00331     mat3(const mat3 & M);
00332     mat3( const nv_scalar& f0,  const nv_scalar& f1,  const nv_scalar& f2,  
00333           const nv_scalar& f3,  const nv_scalar& f4,  const nv_scalar& f5,  
00334           const nv_scalar& f6,  const nv_scalar& f7,  const nv_scalar& f8 )
00335           : a00( f0 ), a10( f1 ), a20( f2 ), 
00336             a01( f3 ), a11( f4 ), a21( f5 ),
00337             a02( f6 ), a12( f7 ), a22( f8) { }
00338 
00339     const vec3 col(const int i) const
00340     {
00341         return vec3(&mat_array[i * 3]);
00342     }
00343 
00344     const vec3 operator[](int i) const
00345     {
00346         return vec3(mat_array[i], mat_array[i + 3], mat_array[i + 6]);
00347     }
00348 
00349     const nv_scalar& operator()(const int& i, const int& j) const
00350     {
00351         return mat_array[ j * 3 + i ];
00352     }
00353 
00354     nv_scalar& operator()(const int& i, const int& j)
00355     {
00356         return  mat_array[ j * 3 + i ];
00357     }
00358 
00359     void set_row(int i, const vec3 & v)
00360     {
00361         mat_array[i] = v.x;
00362         mat_array[i + 3] = v.y;
00363         mat_array[i + 6] = v.z;
00364     }
00365 
00366     void set_col(int i, const vec3 & v)
00367     {
00368         mat_array[i * 3] = v.x;
00369         mat_array[i * 3 + 1] = v.y;
00370         mat_array[i * 3 + 2] = v.z;
00371     }
00372 
00373     void set_rot(const nv_scalar & theta, const vec3 & v);
00374     void set_rot(const vec3 & u, const vec3 & v);
00375 
00376     union {
00377         struct {
00378             nv_scalar a00, a10, a20;        // standard names for components
00379             nv_scalar a01, a11, a21;        // standard names for components
00380             nv_scalar a02, a12, a22;        // standard names for components
00381         };
00382         nv_scalar mat_array[9];     // array access
00383     };
00384 };
00385 
00386 const vec3 operator*(const mat3&, const vec3&);
00387 const vec3 operator*(const vec3&, const mat3&);
00388 
00389 struct DECLSPEC_NV_MATH mat4
00390 {
00391     mat4();
00392     mat4(const nv_scalar * array);
00393     mat4(const mat4 & M);
00394 
00395     mat4( const nv_scalar& f0,  const nv_scalar& f1,  const nv_scalar& f2,  const nv_scalar& f3,
00396           const nv_scalar& f4,  const nv_scalar& f5,  const nv_scalar& f6,  const nv_scalar& f7,
00397           const nv_scalar& f8,  const nv_scalar& f9,  const nv_scalar& f10, const nv_scalar& f11,
00398           const nv_scalar& f12, const nv_scalar& f13, const nv_scalar& f14, const nv_scalar& f15 )
00399           : a00( f0 ), a10( f1 ), a20( f2 ), a30( f3 ),
00400             a01( f4 ), a11( f5 ), a21( f6 ), a31( f7 ),
00401             a02( f8 ), a12( f9 ), a22( f10), a32( f11),
00402             a03( f12), a13( f13), a23( f14), a33( f15) { }
00403  
00404     const vec4 col(const int i) const
00405     {
00406         return vec4(&mat_array[i * 4]);
00407     }
00408     
00409     const vec4 operator[](const int& i) const
00410     {
00411         return vec4(mat_array[i], mat_array[i + 4], mat_array[i + 8], mat_array[i + 12]);
00412     }
00413    
00414     const nv_scalar& operator()(const int& i, const int& j) const
00415     {
00416         return mat_array[ j * 4 + i ];
00417     }
00418 
00419     nv_scalar& operator()(const int& i, const int& j)
00420     {
00421         return  mat_array[ j * 4 + i ];
00422     }
00423 
00424     void set_col(int i, const vec4 & v)
00425     {
00426         mat_array[i * 4] = v.x;
00427         mat_array[i * 4 + 1] = v.y;
00428         mat_array[i * 4 + 2] = v.z;
00429         mat_array[i * 4 + 3] = v.w;
00430     }
00431 
00432     void set_row(int i, const vec4 & v)
00433     {
00434         mat_array[i] = v.x;
00435         mat_array[i + 4] = v.y;
00436         mat_array[i + 8] = v.z;
00437         mat_array[i + 12] = v.w;
00438     }
00439 
00440     mat3 & get_rot(mat3 & M) const;
00441     quat & get_rot(quat & q) const;
00442     void set_rot(const quat & q);
00443     void set_rot(const mat3 & M);
00444     void set_rot(const nv_scalar & theta, const vec3 & v);
00445     void set_rot(const vec3 & u, const vec3 & v);
00446 
00447     void set_translation(const vec3 & t);
00448     vec3 & get_translation(vec3 & t) const;
00449 
00450     mat4 operator*(const mat4&) const;
00451 
00452     union {
00453         struct {
00454             nv_scalar a00, a10, a20, a30;   // standard names for components
00455             nv_scalar a01, a11, a21, a31;   // standard names for components
00456             nv_scalar a02, a12, a22, a32;   // standard names for components
00457             nv_scalar a03, a13, a23, a33;   // standard names for components
00458         };
00459         struct {
00460             nv_scalar _11, _12, _13, _14;   // standard names for components
00461             nv_scalar _21, _22, _23, _24;   // standard names for components
00462             nv_scalar _31, _32, _33, _34;   // standard names for components
00463             nv_scalar _41, _42, _43, _44;   // standard names for components
00464         };
00465         union {
00466             struct {
00467                 nv_scalar b00, b10, b20, p; // standard names for components
00468                 nv_scalar b01, b11, b21, q; // standard names for components
00469                 nv_scalar b02, b12, b22, r; // standard names for components
00470                 nv_scalar x, y, z, w;       // standard names for components
00471             };
00472         };
00473         nv_scalar mat_array[16];     // array access
00474     };
00475 };
00476 
00477 const vec4 operator*(const mat4&, const vec4&);
00478 const vec4 operator*(const vec4&, const mat4&);
00479 
00480 // quaternion
00481 struct DECLSPEC_NV_MATH quat {
00482 public:
00483     quat(nv_scalar x = 0, nv_scalar y = 0, nv_scalar z = 0, nv_scalar w = 1);
00484     quat(const quat& quat);
00485     quat(const vec3& axis, nv_scalar angle);
00486     quat(const mat3& rot);
00487     quat& operator=(const quat& quat);
00488     quat operator-()
00489     {
00490         return quat(-x, -y, -z, -w);
00491     }
00492     quat Inverse();
00493     void Normalize();
00494     void FromMatrix(const mat3& mat);
00495     void ToMatrix(mat3& mat) const;
00496     quat& operator*=(const quat& quat);
00497     static const quat Identity;
00498     nv_scalar& operator[](int i) { return comp[i]; }
00499     const nv_scalar operator[](int i) const { return comp[i]; }
00500     union {
00501         struct {
00502             nv_scalar x, y, z, w;
00503         };
00504         nv_scalar comp[4];
00505     };
00506 };
00507 const quat operator*(const quat&, const quat&);
00508 extern quat & conj(quat & p, const quat & q);
00509 extern quat & add_quats(quat & p, const quat & q1, const quat & q2);
00510 extern nv_scalar dot(const quat & p, const quat & q);
00511 extern quat & dot(nv_scalar s, const quat & p, const quat & q);
00512 extern quat & slerp_quats(quat & p, nv_scalar s, const quat & q1, const quat & q2);
00513 extern quat & axis_to_quat(quat & q, const vec3 & a, const nv_scalar phi);
00514 extern mat3 & quat_2_mat(mat3 &M, const quat &q );
00515 extern quat & mat_2_quat(quat &q,const mat3 &M);
00516 
00517 // constant algebraic values
00518 const nv_scalar array16_id[] =        { nv_one, nv_zero, nv_zero, nv_zero,
00519                                         nv_zero, nv_one, nv_zero, nv_zero,
00520                                         nv_zero, nv_zero, nv_one, nv_zero,
00521                                         nv_zero, nv_zero, nv_zero, nv_one};
00522 
00523 const nv_scalar array16_null[] =      { nv_zero, nv_zero, nv_zero, nv_zero,
00524                                         nv_zero, nv_zero, nv_zero, nv_zero,
00525                                         nv_zero, nv_zero, nv_zero, nv_zero,
00526                                         nv_zero, nv_zero, nv_zero, nv_zero};
00527 
00528 const nv_scalar array16_scale_bias[] = { nv_zero_5, nv_zero,   nv_zero,   nv_zero,
00529                                          nv_zero,   nv_zero_5, nv_zero,   nv_zero,
00530                                          nv_zero,   nv_zero,   nv_zero_5, nv_zero,
00531                                          nv_zero_5, nv_zero_5, nv_zero_5, nv_one};
00532 
00533 const nv_scalar array9_id[] =         { nv_one, nv_zero, nv_zero,
00534                                         nv_zero, nv_one, nv_zero,
00535                                         nv_zero, nv_zero, nv_one};
00536 
00537 
00538 const vec2      vec2_null(nv_zero,nv_zero);
00539 const vec4      vec4_one(nv_one,nv_one,nv_one,nv_one);
00540 const vec3      vec3_one(nv_one,nv_one,nv_one);
00541 const vec3      vec3_null(nv_zero,nv_zero,nv_zero);
00542 const vec3      vec3_x(nv_one,nv_zero,nv_zero);
00543 const vec3      vec3_y(nv_zero,nv_one,nv_zero);
00544 const vec3      vec3_z(nv_zero,nv_zero,nv_one);
00545 const vec3      vec3_neg_x(-nv_one,nv_zero,nv_zero);
00546 const vec3      vec3_neg_y(nv_zero,-nv_one,nv_zero);
00547 const vec3      vec3_neg_z(nv_zero,nv_zero,-nv_one);
00548 const vec4      vec4_null(nv_zero,nv_zero,nv_zero,nv_zero);
00549 const vec4      vec4_x(nv_one,nv_zero,nv_zero,nv_zero);
00550 const vec4      vec4_neg_x(-nv_one,nv_zero,nv_zero,nv_zero);
00551 const vec4      vec4_y(nv_zero,nv_one,nv_zero,nv_zero);
00552 const vec4      vec4_neg_y(nv_zero,-nv_one,nv_zero,nv_zero);
00553 const vec4      vec4_z(nv_zero,nv_zero,nv_one,nv_zero);
00554 const vec4      vec4_neg_z(nv_zero,nv_zero,-nv_one,nv_zero);
00555 const vec4      vec4_w(nv_zero,nv_zero,nv_zero,nv_one);
00556 const vec4      vec4_neg_w(nv_zero,nv_zero,nv_zero,-nv_one);
00557 const quat      quat_id(nv_zero,nv_zero,nv_zero,nv_one);
00558 const mat4      mat4_id(array16_id);
00559 const mat3      mat3_id(array9_id);
00560 const mat4      mat4_null(array16_null);
00561 const mat4      mat4_scale_bias(array16_scale_bias);
00562 
00563 // normalizes a vector and return a reference of itself
00564 extern vec3 & normalize(vec3 & u);
00565 extern vec4 & normalize(vec4 & u);
00566 
00567 // Computes the squared magnitude
00568 inline nv_scalar nv_sq_norm(const vec3 & n)
00569 { return n.x * n.x + n.y * n.y + n.z * n.z; }
00570 
00571 inline nv_scalar nv_sq_norm(const vec4 & n)
00572 { return n.x * n.x + n.y * n.y + n.z * n.z + n.w * n.w; }
00573 
00574 // Computes the magnitude
00575 inline nv_scalar nv_norm(const vec3 & n)
00576 { return sqrtf(nv_sq_norm(n)); }
00577 
00578 inline nv_scalar nv_norm(const vec4 & n)
00579 { return sqrtf(nv_sq_norm(n)); }
00580 
00581 // computes the cross product ( v cross w) and stores the result in u
00582 // i.e.     u = v cross w
00583 extern vec3 & cross(vec3 & u, const vec3 & v, const vec3 & w);
00584 
00585 // computes the dot product ( v dot w) and stores the result in u
00586 // i.e.     u = v dot w
00587 extern nv_scalar & dot(nv_scalar & u, const vec3 & v, const vec3 & w);
00588 extern nv_scalar dot(const vec3 & v, const vec3 & w);
00589 extern nv_scalar & dot(nv_scalar & u, const vec4 & v, const vec4 & w);
00590 extern nv_scalar dot(const vec4 & v, const vec4 & w);
00591 extern nv_scalar & dot(nv_scalar & u, const vec3 & v, const vec4 & w);
00592 extern nv_scalar dot(const vec3 & v, const vec4 & w);
00593 extern nv_scalar & dot(nv_scalar & u, const vec4 & v, const vec3 & w);
00594 extern nv_scalar dot(const vec4 & v, const vec3 & w);
00595 
00596 // compute the reflected vector R of L w.r.t N - vectors need to be 
00597 // normalized
00598 //
00599 //                R     N     L
00600 //                  _       _
00601 //                 |\   ^   /|
00602 //                   \  |  /
00603 //                    \ | /
00604 //                     \|/
00605 //                      +
00606 extern vec3 & reflect(vec3 & r, const vec3 & n, const vec3 & l);
00607 
00608 // Computes u = v * lambda + u
00609 extern vec3 & madd(vec3 & u, const vec3 & v, const nv_scalar & lambda);
00610 // Computes u = v * lambda
00611 extern vec3 & mult(vec3 & u, const vec3 & v, const nv_scalar & lambda);
00612 // Computes u = v * w
00613 extern vec3 & mult(vec3 & u, const vec3 & v, const vec3 & w);
00614 // Computes u = v + w
00615 extern vec3 & add(vec3 & u, const vec3 & v, const vec3 & w);
00616 // Computes u = v - w
00617 extern vec3 & sub(vec3 & u, const vec3 & v, const vec3 & w);
00618 
00619 // Computes u = u * s
00620 extern vec3 & scale(vec3 & u, const nv_scalar s);
00621 extern vec4 & scale(vec4 & u, const nv_scalar s);
00622 
00623 // Computes u = M * v
00624 extern vec3 & mult(vec3 & u, const mat3 & M, const vec3 & v);
00625 extern vec4 & mult(vec4 & u, const mat4 & M, const vec4 & v);
00626 
00627 // Computes u = v * M
00628 extern vec3 & mult(vec3 & u, const vec3 & v, const mat3 & M);
00629 extern vec4 & mult(vec4 & u, const vec4 & v, const mat4 & M);
00630 
00631 // Computes u = M(4x4) * v and divides by w
00632 extern vec3 & mult_pos(vec3 & u, const mat4 & M, const vec3 & v);
00633 // Computes u = M(4x4) * v
00634 extern vec3 & mult_dir(vec3 & u, const mat4 & M, const vec3 & v);
00635 // Computes u = M(4x4) * v and does not divide by w (assumed to be 1)
00636 extern vec3 & mult(vec3& u, const mat4& M, const vec3& v);
00637 
00638 // Computes u = v * M(4x4) and divides by w
00639 extern vec3 & mult_pos(vec3 & u, const vec3 & v, const mat4 & M);
00640 // Computes u = v * M(4x4)
00641 extern vec3 & mult_dir(vec3 & u, const vec3 & v, const mat4 & M);
00642 // Computes u = v * M(4x4) and does not divide by w (assumed to be 1)
00643 extern vec3 & mult(vec3& u, const vec3& v, const mat4& M);
00644 
00645 // Computes A += B
00646 extern mat4 & add(mat4 & A, const mat4 & B);
00647 extern mat3 & add(mat3 & A, const mat3 & B);
00648 
00649 // Computes C = A * B
00650 extern mat4 & mult(mat4 & C, const mat4 & A, const mat4 & B);
00651 extern mat3 & mult(mat3 & C, const mat3 & A, const mat3 & B);
00652 
00653 // Computes B = Transpose(A)
00654 //       T
00655 //  B = A
00656 extern mat3 & transpose(mat3 & B, const mat3 & A);
00657 extern mat4 & transpose(mat4 & B, const mat4 & A);
00658 extern mat3 & transpose(mat3 & B);
00659 extern mat4 & transpose(mat4 & B);
00660 
00661 // Computes B = inverse(A)
00662 //       -1
00663 //  B = A
00664 extern mat4 & invert(mat4 & B, const mat4 & A);
00665 extern mat3 & invert(mat3 & B, const mat3 & A);
00666 
00667 // Computes B = inverse(A)
00668 //                                       T  T
00669 //                   (R t)             (R -R t)
00670 // assuming that A = (0 1) so that B = (0    1)
00671 //  B = A
00672 extern mat4 & invert_rot_trans(mat4 & B, const mat4 & A);
00673 
00674 extern mat4 & look_at(mat4 & M, const vec3 & eye, const vec3 & center, const vec3 & up);
00675 extern mat4 & frustum(mat4 & M, const nv_scalar l, const nv_scalar r, const nv_scalar b, 
00676                const nv_scalar t, const nv_scalar n, const nv_scalar f);
00677 
00678 extern mat4 & perspective(mat4 & M, const nv_scalar fovy, const nv_scalar aspect, const nv_scalar n, const nv_scalar f);
00679 
00680 // quaternion
00681 extern quat & normalize(quat & p);
00682 extern quat & conj(quat & p);
00683 extern quat & conj(quat & p, const quat & q);
00684 extern quat & add_quats(quat & p, const quat & q1, const quat & q2);
00685 extern quat & axis_to_quat(quat & q, const vec3 & a, const nv_scalar phi);
00686 extern mat3 & quat_2_mat(mat3 &M, const quat &q );
00687 extern quat & mat_2_quat(quat &q,const mat3 &M);
00688 extern quat & mat_2_quat(quat &q,const mat4 &M);
00689 
00690 // surface properties
00691 extern mat3 & tangent_basis(mat3 & basis,const vec3 & v0,const vec3 & v1,const vec3 & v2,const vec2 & t0,const vec2 & t1,const vec2 & t2, const vec3 & n);
00692 
00693 // linear interpolation
00694 inline nv_scalar lerp(nv_scalar t, nv_scalar a, nv_scalar b)
00695 { return a * (nv_one - t) + t * b; }
00696 
00697 inline vec3 & lerp(vec3 & w, const nv_scalar & t, const vec3 & u, const vec3 & v)
00698 { w.x = lerp(t, u.x, v.x); w.y = lerp(t, u.y, v.y); w.z = lerp(t, u.z, v.z); return w; }
00699 
00700 // utilities
00701 inline nv_scalar nv_min(const nv_scalar & lambda, const nv_scalar & n)
00702 { return (lambda < n ) ? lambda : n; }
00703 
00704 inline nv_scalar nv_max(const nv_scalar & lambda, const nv_scalar & n)
00705 { return (lambda > n ) ? lambda : n; }
00706 
00707 inline nv_scalar nv_clamp(nv_scalar u, const nv_scalar min, const nv_scalar max)
00708 { u = (u < min) ? min : u; u = (u > max) ? max : u; return u; }
00709 
00710 extern nv_scalar nv_random();
00711 
00712 extern quat & trackball(quat & q, vec2 & pt1, vec2 & pt2, nv_scalar trackballsize);
00713 
00714 extern vec3 & cube_map_normal(int i, int x, int y, int cubesize, vec3 & v);
00715 
00716 // geometry
00717 // computes the area of a triangle
00718 extern nv_scalar nv_area(const vec3 & v1, const vec3 & v2, const vec3 &v3);
00719 // computes the perimeter of a triangle
00720 extern nv_scalar nv_perimeter(const vec3 & v1, const vec3 & v2, const vec3 &v3);
00721 // find the inscribed circle
00722 extern nv_scalar nv_find_in_circle( vec3 & center, const vec3 & v1, const vec3 & v2, const vec3 &v3);
00723 // find the circumscribed circle
00724 extern nv_scalar nv_find_circ_circle( vec3 & center, const vec3 & v1, const vec3 & v2, const vec3 &v3);
00725 
00726 // fast cosine functions
00727 extern nv_scalar fast_cos(const nv_scalar x);
00728 extern nv_scalar ffast_cos(const nv_scalar x);
00729 
00730 // determinant
00731 nv_scalar det(const mat3 & A);
00732 
00733 extern void nv_is_valid(const vec3& v);
00734 extern void nv_is_valid(nv_scalar lambda);
00735 
00736 #endif //_nv_algebra_h_

Generated on Thu Apr 6 15:25:39 2006 for rcssserver3d by  doxygen 1.4.4