00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
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;
00071 };
00072 struct {
00073 nv_scalar s,t;
00074 };
00075 nv_scalar vec_array[2];
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;
00168 };
00169 struct {
00170 nv_scalar s,t,r;
00171 };
00172 nv_scalar vec_array[3];
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;
00277 };
00278 struct {
00279 nv_scalar s,t,r,q;
00280 };
00281 nv_scalar vec_array[4];
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
00318 struct quat;
00319
00320
00321
00322
00323
00324
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;
00379 nv_scalar a01, a11, a21;
00380 nv_scalar a02, a12, a22;
00381 };
00382 nv_scalar mat_array[9];
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;
00455 nv_scalar a01, a11, a21, a31;
00456 nv_scalar a02, a12, a22, a32;
00457 nv_scalar a03, a13, a23, a33;
00458 };
00459 struct {
00460 nv_scalar _11, _12, _13, _14;
00461 nv_scalar _21, _22, _23, _24;
00462 nv_scalar _31, _32, _33, _34;
00463 nv_scalar _41, _42, _43, _44;
00464 };
00465 union {
00466 struct {
00467 nv_scalar b00, b10, b20, p;
00468 nv_scalar b01, b11, b21, q;
00469 nv_scalar b02, b12, b22, r;
00470 nv_scalar x, y, z, w;
00471 };
00472 };
00473 nv_scalar mat_array[16];
00474 };
00475 };
00476
00477 const vec4 operator*(const mat4&, const vec4&);
00478 const vec4 operator*(const vec4&, const mat4&);
00479
00480
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
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
00564 extern vec3 & normalize(vec3 & u);
00565 extern vec4 & normalize(vec4 & u);
00566
00567
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
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
00582
00583 extern vec3 & cross(vec3 & u, const vec3 & v, const vec3 & w);
00584
00585
00586
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
00597
00598
00599
00600
00601
00602
00603
00604
00605
00606 extern vec3 & reflect(vec3 & r, const vec3 & n, const vec3 & l);
00607
00608
00609 extern vec3 & madd(vec3 & u, const vec3 & v, const nv_scalar & lambda);
00610
00611 extern vec3 & mult(vec3 & u, const vec3 & v, const nv_scalar & lambda);
00612
00613 extern vec3 & mult(vec3 & u, const vec3 & v, const vec3 & w);
00614
00615 extern vec3 & add(vec3 & u, const vec3 & v, const vec3 & w);
00616
00617 extern vec3 & sub(vec3 & u, const vec3 & v, const vec3 & w);
00618
00619
00620 extern vec3 & scale(vec3 & u, const nv_scalar s);
00621 extern vec4 & scale(vec4 & u, const nv_scalar s);
00622
00623
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
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
00632 extern vec3 & mult_pos(vec3 & u, const mat4 & M, const vec3 & v);
00633
00634 extern vec3 & mult_dir(vec3 & u, const mat4 & M, const vec3 & v);
00635
00636 extern vec3 & mult(vec3& u, const mat4& M, const vec3& v);
00637
00638
00639 extern vec3 & mult_pos(vec3 & u, const vec3 & v, const mat4 & M);
00640
00641 extern vec3 & mult_dir(vec3 & u, const vec3 & v, const mat4 & M);
00642
00643 extern vec3 & mult(vec3& u, const vec3& v, const mat4& M);
00644
00645
00646 extern mat4 & add(mat4 & A, const mat4 & B);
00647 extern mat3 & add(mat3 & A, const mat3 & B);
00648
00649
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
00654
00655
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
00662
00663
00664 extern mat4 & invert(mat4 & B, const mat4 & A);
00665 extern mat3 & invert(mat3 & B, const mat3 & A);
00666
00667
00668
00669
00670
00671
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
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
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
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
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
00717
00718 extern nv_scalar nv_area(const vec3 & v1, const vec3 & v2, const vec3 &v3);
00719
00720 extern nv_scalar nv_perimeter(const vec3 & v1, const vec3 & v2, const vec3 &v3);
00721
00722 extern nv_scalar nv_find_in_circle( vec3 & center, const vec3 & v1, const vec3 & v2, const vec3 &v3);
00723
00724 extern nv_scalar nv_find_circ_circle( vec3 & center, const vec3 & v1, const vec3 & v2, const vec3 &v3);
00725
00726
00727 extern nv_scalar fast_cos(const nv_scalar x);
00728 extern nv_scalar ffast_cos(const nv_scalar x);
00729
00730
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_