home *** CD-ROM | disk | FTP | other *** search
/ Enter 2005 March / ENTER.ISO / files / fwp-0.0.6-win32-installer.exe / vectormath.h < prev    next >
Encoding:
C/C++ Source or Header  |  2004-12-18  |  6.7 KB  |  151 lines
  1. #ifndef __vectormath_h__
  2. #define __vectormath_h__
  3.  
  4. /*!
  5. \file vectormath.h
  6. \author Karsten Schwenk
  7.  
  8. \brief This file conatins some often used (fairly simple) vector analysis routines.
  9.  
  10. Most functions in this file come in versions for two, three and four dimensions, following the naming scheme \c functionameXd , where X can be 2, 3 or 4. (E.g. \c vectorInit2d, \c vectorInit3d, ...) All function names start with \c vector... .
  11.  
  12. Functions that return a vector do so by filling in their \b last argument; passing in one of the other arguments here is save (e.g. \c vectorAdd3d(a,b,a) ). Most of them will also return a pointer to that vector to enable nesting of functions.
  13.  
  14. Since the dimension is the only difference between those functions I will only document the version for the \b lowest dimension.
  15. So if you are searching for \c vectorDotP4d and find it undocumented, look at \c vectorDotP2d.
  16.  
  17. \see matrixmath.h
  18.  
  19. */
  20.  
  21. #include <float.h>
  22.  
  23. #define PI 3.141592654f
  24. #define DEG(x) ( (x)*(180.0f/PI) )
  25. #define RAD(x) ( (x)*(PI/180.0f) )
  26. #define DOT_PRODUCT_3D(a,b) ( ((a)[0]*(b)[0]) + ((a)[1]*(b)[1]) + ((a)[2]*(b)[2]) )
  27.  
  28. /*
  29. #define vectorInit(x,y,z,v) vectorInit3d(x,y,z,v)
  30. #define vectorCopy(a,b) vectorCopy3d(a,b)
  31. #define vectorAdd(a,b,c) vectorAdd3d(a,b,c)
  32. #define vectorSub(a,b,c) vectorSub3d(a,b,c)
  33. #define vectorDotP(a,b,c) vectorDotP3d(a,b,c)
  34. #define vectorCrossP(a,b,c) vectorCrossP3d(a,b,c)
  35. #define vectorScale(s,a,b) vectorScaleP3d(s,a,b)
  36. #define vectorNormalize(a,b) vectorNormalize3d(a,b)
  37. #define vectorLength(a) vectorLength3d(a)
  38. #define vectorDistance(a,b) vectorDistance3d(a,b)
  39. */
  40.  
  41. typedef float vecbase_t;        //!< our vecbase type (could although bee switched to \c double)
  42. typedef vecbase_t vec2_t[2];    //!< a two dimensinal vector (not more than an array of two \c floats)
  43. typedef vecbase_t vec3_t[3];    //!< a three dimensional vector
  44. typedef vecbase_t vec4_t[4];    //!< a four dimensional vector
  45.  
  46. extern vec4_t e1;
  47. extern vec4_t e2;
  48. extern vec4_t e3;
  49. extern vec4_t e4;
  50.  
  51. //! These functions initialize a vector with values
  52. void vectorInit2d(vecbase_t x, vecbase_t y, vec2_t v);
  53. void vectorInit3d(vecbase_t x, vecbase_t y, vecbase_t z, vec3_t v);
  54. void vectorInit4d(vecbase_t x, vecbase_t y, vecbase_t z, vecbase_t w, vec4_t v);
  55.  
  56. //! These functions copy the values of vector source into destination
  57. void vectorCopy2d(vec2_t source, vec2_t destination);
  58. void vectorCopy3d(vec3_t source, vec3_t destination);
  59. void vectorCopy4d(vec4_t source, vec4_t destination);
  60.  
  61. //! These functions add vector b to a (component-wise) and put the result in c.
  62. vecbase_t* vectorAdd2d(vec2_t a, vec2_t b, vec2_t c);
  63. vecbase_t* vectorAdd3d(vec3_t a, vec3_t b, vec3_t c);
  64. vecbase_t* vectorAdd4d(vec4_t a, vec4_t b, vec4_t c);
  65.  
  66. //! These functions substract vector b from a (component-wise) and put the result in c.
  67. vecbase_t* vectorSub2d(vec2_t a, vec2_t b, vec2_t c);
  68. vecbase_t* vectorSub3d(vec3_t a, vec3_t b, vec3_t c);
  69. vecbase_t* vectorSub4d(vec4_t a, vec4_t b, vec4_t c);
  70.  
  71. //! These functions return the dot product (i.e. inner product) of a and b.
  72. vecbase_t vectorDotP2d(vec2_t a, vec2_t b);
  73. vecbase_t vectorDotP3d(vec3_t a, vec3_t b);
  74. vecbase_t vectorDotP4d(vec4_t a, vec4_t b);
  75.  
  76. //! This function calculates the cross product (i.e. outer product) of a and b and puts it in c.
  77. vecbase_t* vectorCrossP3d(vec3_t a, vec3_t b, vec3_t c);
  78.  
  79. //! These functions scale (i.e. multiply) vector a by the scalar s and put the resulting vector in b.
  80. vecbase_t* vectorScale2d(vecbase_t s, vec2_t a, vec2_t b);
  81. vecbase_t* vectorScale3d(vecbase_t s, vec3_t a, vec3_t b);
  82. vecbase_t* vectorScale4d(vecbase_t s, vec4_t a, vec4_t b);
  83.  
  84. //! These functions calculate c=a+sb.
  85. vecbase_t* vectorMA2d(vec2_t a, vecbase_t s, vec2_t b, vec2_t c);    //c=a+sb
  86. vecbase_t* vectorMA3d(vec3_t a, vecbase_t s, vec3_t b, vec3_t c);    //c=a+sb
  87. vecbase_t* vectorMA4d(vec4_t a, vecbase_t s, vec4_t b, vec4_t c);    //c=a+sb
  88.  
  89. //! These functions calculate c=ua+vb (i.e. a linear combination of a and b).
  90. vecbase_t* vectorLinCombi2d(vecbase_t u, vec2_t a, vecbase_t v, vec2_t b, vec2_t c);    // c=u*a+v*b
  91. vecbase_t* vectorLinCombi3d(vecbase_t u, vec3_t a, vecbase_t v, vec3_t b, vec3_t c);    // c=u*a+v*b
  92. vecbase_t* vectorLinCombi4d(vecbase_t u, vec4_t a, vecbase_t v, vec4_t b, vec4_t c);    // c=u*a+v*b
  93.  
  94. //! These functions return the magnitude of v.
  95. vecbase_t vectorLength2d(vec2_t v);
  96. vecbase_t vectorLength3d(vec3_t v);
  97. vecbase_t vectorLength4d(vec4_t v);
  98.  
  99. //! These functions return the squared magnitude of v (saves the square root).
  100. vecbase_t vectorLengthSquared2d(vec2_t v);
  101. vecbase_t vectorLengthSquared3d(vec3_t v);
  102. vecbase_t vectorLengthSquared4d(vec4_t v);
  103.  
  104. //! These functions normalize vector a and put the result in b.
  105. vecbase_t* vectorNormalize2d(vec2_t a, vec2_t b);
  106. vecbase_t* vectorNormalize3d(vec3_t a, vec3_t b);
  107. vecbase_t* vectorNormalize4d(vec4_t a, vec4_t b);
  108.  
  109. vecbase_t* vectorNormalizeFast2d(vec2_t a, vec2_t b);
  110. vecbase_t* vectorNormalizeFast3d(vec3_t a, vec3_t b);
  111. vecbase_t* vectorNormalizeFast4d(vec4_t a, vec4_t b);
  112.  
  113. //! These functions return the distance from point a to point b.
  114. vecbase_t vectorPointDistance2d(vec2_t a, vec2_t b);
  115. vecbase_t vectorPointDistance3d(vec3_t a, vec3_t b);
  116. vecbase_t vectorPointDistance4d(vec4_t a, vec4_t b);
  117.  
  118. //! These functions return the squared distance from point a to point b.
  119. vecbase_t vectorPointDistanceSquared2d(vec2_t a, vec2_t b);
  120. vecbase_t vectorPointDistanceSquared3d(vec3_t a, vec3_t b);
  121. vecbase_t vectorPointDistanceSquared4d(vec4_t a, vec4_t b);
  122.  
  123. //! These functions return the angle between a and b
  124. vecbase_t vectorAngle2d(vec2_t a, vec2_t b);
  125. vecbase_t vectorAngle3d(vec3_t a, vec3_t b);
  126. vecbase_t vectorAngle4d(vec4_t a, vec4_t b);
  127.  
  128. //! These functions check whether or not a and b are equal (WITH AN EPSILON CHECK!).
  129. bool vectorEqual2d(vec2_t a, vec2_t b);
  130. bool vectorEqual3d(vec3_t a, vec3_t b);
  131. bool vectorEqual4d(vec4_t a, vec4_t b);
  132.  
  133. //! These functions check whether or not a and b are equal (WITH AN EXACT CHECK!).
  134. bool vectorEqualExact2d(vec2_t a, vec2_t b);
  135. bool vectorEqualExact3d(vec3_t a, vec3_t b);
  136. bool vectorEqualExact4d(vec4_t a, vec4_t b);
  137.  
  138. //! These functions check whether or not a and b are linearly dependent.
  139. bool vectorLinDep2d(vec2_t a, vec2_t b);
  140. bool vectorLinDep3d(vec3_t a, vec3_t b);
  141. bool vectorLinDep4d(vec4_t a, vec4_t b);
  142.  
  143. //! This function rotates vec angle RADIANS around normal and puts the result in ret
  144. vecbase_t* vectorRotateAroundNormal3d(vec3_t vec, vec3_t normal, vecbase_t angle, vec3_t ret);
  145.  
  146. //! This function rotates vec angle RADIANS in direction dir and puts the result in ret
  147. vecbase_t* vectorRotateInDir3d(vec3_t vec, vec3_t dir, vecbase_t angle, vec3_t ret);
  148.  
  149.  
  150. #endif    /* __vectormath_h__ */
  151.